@jbrowse/bandage-core 6.0.0 → 6.0.2

package/dist/chunks/chunk-AB35TJST.js

@@ -0,0 +1,67 @@
+// src/overlayLabels.ts
+var LABEL_PX = 11;
+var LABEL_CHAR_PX = 6.2;
+var LABEL_PAD = 4;
+function labelWidth(text) {
+  return text.length * LABEL_CHAR_PX + LABEL_PAD * 2;
+}
+function overlaps(a, b) {
+  return a.x0 < b.x1 && a.x1 > b.x0 && a.y0 < b.y1 && a.y1 > b.y0;
+}
+function offFrame(box, frame) {
+  return box.x1 <= 0 || box.x0 >= frame.width || box.y1 <= 0 || box.y0 >= frame.height;
+}
+function insideFrame(box, frame) {
+  return box.x0 >= 0 && box.x1 <= frame.width && box.y0 >= 0 && box.y1 <= frame.height;
+}
+function occupancy(frame, reserved = []) {
+  const placed = [...reserved];
+  return (box) => {
+    if (offFrame(box, frame) || placed.some((p) => overlaps(p, box))) {
+      return false;
+    }
+    placed.push(box);
+    return true;
+  };
+}
+function placeLabels(candidates, frame, take) {
+  const out = [];
+  const row = LABEL_PX + LABEL_PAD * 2;
+  const place = (c, text) => {
+    const w = labelWidth(text);
+    const direction = c.y > frame.height / 2 ? -1 : 1;
+    for (let tries = 0; tries <= (c.stack ?? 0); tries++) {
+      const y = c.y + direction * tries * row;
+      const box = {
+        x0: c.x - w / 2,
+        x1: c.x + w / 2,
+        y0: y - LABEL_PX - LABEL_PAD,
+        y1: y + LABEL_PAD
+      };
+      if (offFrame(box, frame)) {
+        return void 0;
+      }
+      if (insideFrame(box, frame) && (c.fits?.(box) ?? true) && take(box)) {
+        return { ...c, text, y, w };
+      }
+    }
+    return void 0;
+  };
+  for (const c of candidates) {
+    const placed = place(c, c.text) ?? (c.fallback === void 0 ? void 0 : place(c, c.fallback));
+    if (placed) {
+      out.push(placed);
+    }
+  }
+  return out;
+}
+
+export {
+  LABEL_PX,
+  LABEL_CHAR_PX,
+  LABEL_PAD,
+  labelWidth,
+  overlaps,
+  occupancy,
+  placeLabels
+};

package/dist/chunks/chunk-AE3UQZY3.js

@@ -0,0 +1,43 @@
+import {
+  formatBp,
+  groupDigits
+} from "./chunk-HCANBJDD.js";
+
+// src/walkKey.ts
+function rangeText(contig, start, end) {
+  const s = Math.round(start);
+  const e = Math.round(end);
+  return `${contig ? `${contig}:` : ""}${groupDigits(s)}-${groupDigits(e)} (${formatBp(e - s)})`;
+}
+function walkKey(walk, reference) {
+  const { field } = walk.encoding;
+  const own = walk.range ? rangeText(walk.range.contig, walk.range.start, walk.range.end) : void 0;
+  const scale = field === "progress" ? own : field === "reference" && reference ? rangeText(reference.name, reference.start, reference.end) : void 0;
+  const spanned = walk.range ? walk.range.end - walk.range.start : walk.bp;
+  const outside = spanned - walk.bp;
+  return {
+    delta: walk.referenceBp === void 0 || spanned === walk.referenceBp ? "" : ` ${spanned > walk.referenceBp ? "+" : "\u2212"}${formatBp(Math.abs(spanned - walk.referenceBp))}`,
+    outside: outside > 0 ? `, ${formatBp(outside)} outside the cut` : "",
+    reversed: walk.reversedBp > 0 ? `, ${formatBp(walk.reversedBp)} reversed` : "",
+    shades: field !== "walk",
+    scale,
+    hover: scale === own ? void 0 : own
+  };
+}
+function walkPosition(walk, nodeId, length) {
+  const progress = walk.progress.get(nodeId);
+  const range = walk.range;
+  if (progress === void 0 || !range) {
+    return void 0;
+  }
+  const start = Math.round(
+    range.start + progress * (range.end - range.start) - length / 2
+  );
+  return `${range.contig}:${groupDigits(start)}-${groupDigits(start + length)}`;
+}
+
+export {
+  rangeText,
+  walkKey,
+  walkPosition
+};

package/dist/chunks/chunk-BJV2W4KZ.js

@@ -0,0 +1,257 @@
+import {
+  EdgeSpatialIndex,
+  SpatialIndex
+} from "./chunk-LVZZH2NI.js";
+import {
+  pathRibbonOffsets,
+  translateCurves,
+  yToXOf
+} from "./chunk-3PLYZLYV.js";
+
+// src/util/hitDetection.ts
+function distanceToSegment(px, py, x1, y1, x2, y2) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const lenSq = dx * dx + dy * dy;
+  if (lenSq === 0) {
+    return Math.hypot(px - x1, py - y1);
+  }
+  const t = Math.max(0, Math.min(1, ((px - x1) * dx + (py - y1) * dy) / lenSq));
+  return Math.hypot(px - (x1 + t * dx), py - (y1 + t * dy));
+}
+function distanceToCubicBezier(px, py, x1, y1, cx1, cy1, cx2, cy2, x2, y2) {
+  let minDist = Infinity;
+  const samples = 20;
+  let lastX = x1;
+  let lastY = y1;
+  for (let i = 1; i <= samples; i++) {
+    const t = i / samples;
+    const u = 1 - t;
+    const bx = u * u * u * x1 + 3 * u * u * t * cx1 + 3 * u * t * t * cx2 + t * t * t * x2;
+    const by = u * u * u * y1 + 3 * u * u * t * cy1 + 3 * u * t * t * cy2 + t * t * t * y2;
+    minDist = Math.min(minDist, distanceToSegment(px, py, lastX, lastY, bx, by));
+    lastX = bx;
+    lastY = by;
+  }
+  return minDist;
+}
+function distanceToBezierCurve(px, py, c) {
+  return distanceToCubicBezier(
+    px,
+    py,
+    c.x0,
+    c.y0,
+    c.cx0,
+    c.cy0,
+    c.cx1,
+    c.cy1,
+    c.x1,
+    c.y1
+  );
+}
+function distanceToEdgeCurves(px, py, curves, yToX = 1) {
+  let minDist = Infinity;
+  for (const c of curves) {
+    const d = distanceToBezierCurve(
+      px,
+      py,
+      yToX === 1 ? c : {
+        x0: c.x0,
+        y0: c.y0 * yToX,
+        cx0: c.cx0,
+        cy0: c.cy0 * yToX,
+        cx1: c.cx1,
+        cy1: c.cy1 * yToX,
+        x1: c.x1,
+        y1: c.y1 * yToX
+      }
+    );
+    if (d < minDist) {
+      minDist = d;
+    }
+  }
+  return minDist;
+}
+var nodeCache = /* @__PURE__ */ new WeakMap();
+function getSpatialIndex(nodePositions, version) {
+  const cached = nodeCache.get(nodePositions);
+  if (cached?.version === version) {
+    return cached.index;
+  }
+  const index = new SpatialIndex(nodePositions);
+  nodeCache.set(nodePositions, { version, index });
+  return index;
+}
+var edgeCache = /* @__PURE__ */ new WeakMap();
+function getEdgeSpatialIndex(nodePositions, graph, drawPaths, axis, version, deletions, routes, stranded = false) {
+  const cached = edgeCache.get(nodePositions);
+  if (cached?.graph === graph && cached.drawPaths === drawPaths && cached.scaleX === axis.scaleX && cached.scaleY === axis.scaleY && cached.version === version && cached.deletions === deletions && cached.routes === routes && cached.stranded === stranded) {
+    return cached.index;
+  }
+  const index = new EdgeSpatialIndex(
+    nodePositions,
+    graph,
+    drawPaths,
+    axis,
+    void 0,
+    deletions,
+    version,
+    routes,
+    stranded
+  );
+  edgeCache.set(nodePositions, {
+    graph,
+    drawPaths,
+    scaleX: axis.scaleX,
+    scaleY: axis.scaleY,
+    version,
+    index,
+    deletions,
+    routes,
+    stranded
+  });
+  return index;
+}
+var MIN_NODE_REACH_PX = 5;
+function findHoveredNode(nodePositions, graphX, graphY, axis, version = 0, ink) {
+  const yToX = yToXOf(axis);
+  const index = getSpatialIndex(nodePositions, version);
+  const reach = (px) => Math.max(MIN_NODE_REACH_PX, px) / axis.scaleX;
+  const queryReach = reach(ink?.maxHalfWidthPx ?? 0);
+  const candidates = index.query(graphX, graphY, queryReach, queryReach / yToX);
+  let hovered = null;
+  let best = Infinity;
+  for (const { nodeId, segmentIdx } of candidates) {
+    const segments = nodePositions[nodeId];
+    const dist = distanceToSegment(
+      graphX,
+      graphY * yToX,
+      segments[segmentIdx].x,
+      segments[segmentIdx].y * yToX,
+      segments[segmentIdx + 1].x,
+      segments[segmentIdx + 1].y * yToX
+    );
+    if (dist < best && dist < reach(ink?.halfWidthPx(nodeId) ?? 0)) {
+      best = dist;
+      hovered = nodeId;
+    }
+  }
+  return hovered;
+}
+function segmentMeetsBox(a, b, box) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  let t0 = 0;
+  let t1 = 1;
+  for (const [p, q] of [
+    [-dx, a.x - box.x0],
+    [dx, box.x1 - a.x],
+    [-dy, a.y - box.y0],
+    [dy, box.y1 - a.y]
+  ]) {
+    if (p === 0) {
+      if (q < 0) {
+        return false;
+      }
+    } else if (p < 0) {
+      t0 = Math.max(t0, q / p);
+    } else {
+      t1 = Math.min(t1, q / p);
+    }
+  }
+  return t0 <= t1;
+}
+function nodesUnderBox(nodePositions, t, version = 0) {
+  const index = getSpatialIndex(nodePositions, version);
+  const screen = (p) => ({
+    x: p.x * t.scaleX + t.translateX,
+    y: p.y * t.scaleY + t.translateY
+  });
+  return (box) => {
+    const hits = /* @__PURE__ */ new Set();
+    const candidates = index.query(
+      ((box.x0 + box.x1) / 2 - t.translateX) / t.scaleX,
+      ((box.y0 + box.y1) / 2 - t.translateY) / t.scaleY,
+      Math.abs((box.x1 - box.x0) / 2 / t.scaleX),
+      Math.abs((box.y1 - box.y0) / 2 / t.scaleY)
+    );
+    for (const { nodeId, segmentIdx } of candidates) {
+      const line = nodePositions[nodeId];
+      if (!hits.has(nodeId) && segmentMeetsBox(
+        screen(line[segmentIdx]),
+        screen(line[segmentIdx + 1]),
+        box
+      )) {
+        hits.add(nodeId);
+      }
+    }
+    return hits;
+  };
+}
+function findHoveredEdge(nodePositions, graph, graphX, graphY, axis, drawPaths, version = 0, deletions, hiddenEdges, deletionRoutes, stranded = false) {
+  const yToX = yToXOf(axis);
+  const edgeThreshold = 10 / axis.scaleX;
+  const edgeIndex = getEdgeSpatialIndex(
+    nodePositions,
+    graph,
+    drawPaths,
+    axis,
+    version,
+    deletions,
+    deletionRoutes,
+    stranded
+  );
+  const candidates = edgeIndex.query(
+    graphX,
+    graphY,
+    edgeThreshold,
+    edgeThreshold / yToX
+  );
+  let hovered = null;
+  let best = edgeThreshold;
+  for (const edgeIdx of candidates) {
+    const edge = graph.edges[edgeIdx];
+    const fromSegments = nodePositions[edge.from];
+    const toSegments = nodePositions[edge.to];
+    if (!fromSegments?.length || !toSegments?.length || hiddenEdges?.has(edgeIdx)) {
+      continue;
+    }
+    const numPaths = edge.pathIds?.length ?? 0;
+    const baseCurves = edgeIndex.getCurves(edgeIdx);
+    if (!baseCurves) {
+      continue;
+    }
+    let dist;
+    if (!drawPaths || numPaths === 0) {
+      dist = distanceToEdgeCurves(graphX, graphY * yToX, baseCurves, yToX);
+    } else {
+      let minDist = Infinity;
+      for (const offset of pathRibbonOffsets(
+        fromSegments,
+        toSegments,
+        numPaths,
+        axis
+      )) {
+        const curves = offset.x === 0 && offset.y === 0 ? baseCurves : translateCurves(baseCurves, offset.x, offset.y);
+        const d = distanceToEdgeCurves(graphX, graphY * yToX, curves, yToX);
+        if (d < minDist) {
+          minDist = d;
+        }
+      }
+      dist = minDist;
+    }
+    if (dist < best) {
+      best = dist;
+      hovered = edgeIdx;
+    }
+  }
+  return hovered;
+}
+
+export {
+  distanceToSegment,
+  distanceToCubicBezier,
+  findHoveredNode,
+  nodesUnderBox,
+  findHoveredEdge
+};

package/dist/chunks/chunk-BPLIXMH7.js

@@ -0,0 +1,52 @@
+// src/pansn.ts
+var SEP = "#";
+function panSNSample(refName) {
+  return refName.split(SEP)[0];
+}
+var GENERIC_SAMPLES = /* @__PURE__ */ new Set(["_gbwt_ref"]);
+function isGenericSample(sample) {
+  return GENERIC_SAMPLES.has(sample);
+}
+function panSNHaplotype(refName) {
+  const parts = refName.split(SEP);
+  return parts.length >= 3 ? `${parts[0]}${SEP}${parts[1]}` : void 0;
+}
+function panSNContig(refName) {
+  const parts = refName.split(SEP);
+  return parts.length >= 3 ? parts.slice(2).join(SEP) : parts.length === 2 ? parts[1] : refName;
+}
+function panSNMatchesPrefix(refName, prefix) {
+  return prefix !== void 0 && (refName === prefix || refName.startsWith(prefix + SEP));
+}
+function assemblyNameToPanSN(adapter) {
+  return adapter.getConf("assemblyNameToPanSN") ?? {};
+}
+function resolvePanSNPrefix(adapter, name) {
+  return name === void 0 ? void 0 : assemblyNameToPanSN(adapter)[name] ?? name;
+}
+var asmByPrefixCache = /* @__PURE__ */ new WeakMap();
+function assemblyByPanSNPrefix(adapter) {
+  let out = asmByPrefixCache.get(adapter);
+  if (out === void 0) {
+    const map = assemblyNameToPanSN(adapter);
+    out = {};
+    for (const asm of /* @__PURE__ */ new Set([
+      ...Object.keys(map),
+      ...adapter.getConf("assemblyNames")
+    ])) {
+      out[map[asm] ?? asm] = asm;
+    }
+    asmByPrefixCache.set(adapter, out);
+  }
+  return out;
+}
+
+export {
+  panSNSample,
+  isGenericSample,
+  panSNHaplotype,
+  panSNContig,
+  panSNMatchesPrefix,
+  resolvePanSNPrefix,
+  assemblyByPanSNPrefix
+};

package/dist/chunks/chunk-BXEPA4KS.js

@@ -0,0 +1,179 @@
+// src/genes/geneFiles.ts
+var GENE_TYPE = /(gene|gene_segment|RNA|transcript)$/i;
+var isGene = (type) => GENE_TYPE.test(type) || type === "CDS" || type === "exon";
+function mergedIntervals(intervals) {
+  const out = [];
+  for (const iv of [...intervals].sort((a, b) => a.start - b.start)) {
+    const last = out.at(-1);
+    if (last && iv.start <= last.end) {
+      last.end = Math.max(last.end, iv.end);
+    } else {
+      out.push({ ...iv });
+    }
+  }
+  return out;
+}
+function strandOf(s) {
+  return s === "+" ? 1 : s === "-" ? -1 : 0;
+}
+function unescape(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function attributes(column) {
+  const out = /* @__PURE__ */ new Map();
+  for (const pair of column.split(";")) {
+    const eq = pair.indexOf("=");
+    if (eq > 0) {
+      out.set(pair.slice(0, eq).trim(), unescape(pair.slice(eq + 1).trim()));
+    }
+  }
+  return out;
+}
+function gff3Row(line) {
+  const cols = line.split("	");
+  const start = Number(cols[3]);
+  const end = Number(cols[4]);
+  if (cols.length < 9 || !Number.isInteger(start) || !Number.isInteger(end)) {
+    return void 0;
+  }
+  return {
+    refName: cols[0],
+    type: cols[2],
+    start: start - 1,
+    end,
+    strand: strandOf(cols[6]),
+    attrs: attributes(cols[8])
+  };
+}
+function genesFromGff3Lines(lines) {
+  const rows = [];
+  for (const line of lines) {
+    if (line.startsWith("##FASTA")) {
+      break;
+    }
+    const row = line.startsWith("#") ? void 0 : gff3Row(line);
+    if (row) {
+      rows.push(row);
+    }
+  }
+  const parentOf = /* @__PURE__ */ new Map();
+  for (const { attrs } of rows) {
+    const id = attrs.get("ID");
+    const parent = attrs.get("Parent")?.split(",")[0];
+    if (id && parent) {
+      parentOf.set(id, parent);
+    }
+  }
+  const rootOf = (row) => {
+    let id = row.attrs.get("Parent")?.split(",")[0] ?? row.attrs.get("ID");
+    if (!id) {
+      return row.attrs.get("gene_id");
+    }
+    const seen = /* @__PURE__ */ new Set();
+    while (id && parentOf.has(id) && !seen.has(id)) {
+      seen.add(id);
+      id = parentOf.get(id);
+    }
+    return id;
+  };
+  const groups = /* @__PURE__ */ new Map();
+  rows.forEach((row, i) => {
+    const root = rootOf(row) ?? `#${i}`;
+    const key = `${row.refName}	${root}`;
+    const group = groups.get(key) ?? groups.set(key, { rows: [] }).get(key);
+    group.rows.push(row);
+    if (!row.attrs.has("Parent") && !group.top) {
+      group.top = row;
+    }
+  });
+  const genes = [];
+  for (const [key, { top, rows: rows2 }] of groups) {
+    if (top && !isGene(top.type)) {
+      continue;
+    }
+    const first = top ?? rows2[0];
+    const start = top?.start ?? Math.min(...rows2.map((r) => r.start));
+    const end = top?.end ?? Math.max(...rows2.map((r) => r.end));
+    const a = first.attrs;
+    const spans = (type) => rows2.filter((r) => r.type === type).map((r) => ({ start: r.start, end: r.end }));
+    const exons = spans("exon");
+    const coding = spans("CDS");
+    const transcribed = rows2.some(
+      (r) => r !== top && r.type !== "exon" && r.type !== "CDS"
+    );
+    genes.push({
+      name: a.get("Name") ?? a.get("gene_name") ?? a.get("gene") ?? a.get("gene_id") ?? key.split("	")[1],
+      refName: first.refName,
+      start,
+      end,
+      strand: first.strand,
+      // A range read holds only the rows over its window, so a gene with
+      // transcripts but no exon or CDS there is intronic in it. Only a gene
+      // with no transcripts, as a bacterium's gene and CDS, is one exon.
+      exons: exons.length ? mergedIntervals(exons) : transcribed ? mergedIntervals(coding) : [{ start, end }]
+    });
+  }
+  return genes;
+}
+function mergeOverlappingByName(genes) {
+  const out = [];
+  const open = /* @__PURE__ */ new Map();
+  for (const g of [...genes].sort((a, b) => a.start - b.start)) {
+    const key = `${g.refName}	${g.strand}	${g.name}`;
+    const last = open.get(key);
+    if (last && g.start < last.end) {
+      last.end = Math.max(last.end, g.end);
+      last.exons = mergedIntervals([...last.exons, ...g.exons]);
+    } else {
+      const gene = { ...g, exons: mergedIntervals(g.exons) };
+      out.push(gene);
+      open.set(key, gene);
+    }
+  }
+  return out;
+}
+function genesFromBed(text) {
+  const rows = [];
+  for (const line of text.split("\n")) {
+    const cols = line.replace(/\r$/, "").split("	");
+    const start = Number(cols[1]);
+    const end = Number(cols[2]);
+    if (/^(#|track|browser)/.test(line) || cols.length < 3 || !Number.isInteger(start) || !(end > start)) {
+      continue;
+    }
+    const refName = cols[0];
+    const name = cols[3] && cols[3] !== "." ? cols[3] : `${refName}:${start + 1}-${end}`;
+    const sizes = cols[10]?.split(",").filter((s) => s !== "").map(Number);
+    const starts = cols[11]?.split(",").filter((s) => s !== "").map(Number);
+    const blocks = sizes?.length && sizes.length === starts?.length ? sizes.map((size, i) => ({
+      start: start + starts[i],
+      end: start + starts[i] + size
+    })) : [{ start, end }];
+    rows.push({
+      name,
+      refName,
+      start,
+      end,
+      strand: strandOf(cols[5]),
+      exons: blocks
+    });
+  }
+  return mergeOverlappingByName(rows);
+}
+function genesFromText(text) {
+  const first = text.split("\n", 1e3).find((l) => l.trim() !== "" && !/^(#|track|browser)/.test(l));
+  const cols = first?.split("	") ?? [];
+  return /^\d+$/.test(cols[1] ?? "") && /^\d+$/.test(cols[2] ?? "") ? genesFromBed(text) : genesFromGff3Lines(text.split(/\r?\n/));
+}
+
+export {
+  mergedIntervals,
+  genesFromGff3Lines,
+  mergeOverlappingByName,
+  genesFromBed,
+  genesFromText
+};

package/dist/chunks/chunk-C44YRP5F.js

@@ -0,0 +1,85 @@
+// src/gaf/parseGaf.ts
+var STEP = /([><])([^><]+)/g;
+function parseGafPath(column) {
+  if (!column.startsWith(">") && !column.startsWith("<")) {
+    return void 0;
+  }
+  const steps = [];
+  for (const [, arrow, name] of column.matchAll(STEP)) {
+    steps.push({ name, strand: arrow === ">" ? "+" : "-" });
+  }
+  return steps;
+}
+function parseGafLine(line) {
+  const columns = line.split("	");
+  if (columns.length < 12 || line.startsWith("#")) {
+    return void 0;
+  }
+  const path = parseGafPath(columns[5]);
+  if (!path) {
+    return void 0;
+  }
+  let cs;
+  let secondary = false;
+  for (let i = 12; i < columns.length; i++) {
+    const tag = columns[i];
+    if (tag.startsWith("cs:Z:")) {
+      cs = tag.slice(5);
+    } else if (tag === "tp:A:S") {
+      secondary = true;
+    }
+  }
+  return {
+    name: columns[0],
+    queryLength: +columns[1],
+    queryStart: +columns[2],
+    queryEnd: +columns[3],
+    strand: columns[4] === "-" ? "-" : "+",
+    path,
+    pathLength: +columns[6],
+    pathStart: +columns[7],
+    pathEnd: +columns[8],
+    matches: +columns[9],
+    blockLength: +columns[10],
+    mappingQuality: +columns[11],
+    secondary,
+    ...cs === void 0 ? {} : { cs }
+  };
+}
+function parseGaf(text) {
+  const records = [];
+  for (const line of text.split("\n")) {
+    const record = parseGafLine(line.trimEnd());
+    if (record) {
+      records.push(record);
+    }
+  }
+  return records;
+}
+var CS_OP = /:(\d+)|=([A-Za-z]+)|\*[a-zA-Z]([a-zA-Z])|\+([A-Za-z]+)|-([A-Za-z]+)|~[a-z]{2}(\d+)[a-z]{2}/g;
+function parseCs(cs) {
+  const ops = [];
+  for (const m of cs.matchAll(CS_OP)) {
+    if (m[1] !== void 0) {
+      ops.push({ op: "match", length: +m[1] });
+    } else if (m[2] !== void 0) {
+      ops.push({ op: "match", length: m[2].length });
+    } else if (m[3] !== void 0) {
+      ops.push({ op: "substitution", seq: m[3].toUpperCase() });
+    } else if (m[4] !== void 0) {
+      ops.push({ op: "insertion", seq: m[4].toUpperCase() });
+    } else if (m[5] !== void 0) {
+      ops.push({ op: "deletion", length: m[5].length });
+    } else if (m[6] !== void 0) {
+      ops.push({ op: "match", length: +m[6] });
+    }
+  }
+  return ops;
+}
+
+export {
+  parseGafPath,
+  parseGafLine,
+  parseGaf,
+  parseCs
+};