@sjcrh/proteinpaint-shared 2.187.0 → 2.188.0

package/src/index.js

@@ -1,26 +0,0 @@
-// please list in alphanumeric order
-export * from "./bulk.js"
-export * from "./clustering.js"
-export * from "./common.js"
-export * from "./compute.percentile.js"
-export * from "./fetch-helpers.js"
-export * from "./fileSize.js"
-export * from "./filter.js"
-export * from "./hash.js"
-export * from "./helpers.js"
-export * from "./joinUrl.js"
-export * from "./mds3tk.js"
-export * from "./roundValue.js"
-export * from "./termdb.bins.js"
-export * from "./termdb.initbinconfig.js"
-export * from "./termdb.usecase.js"
-export * from "./terms.js"
-export * from "./time.js"
-export * from "./tree.js"
-// do `npm run esm` to generate .js file from .ts file
-export * from "./urljson.js"
-export * from "./vcf.ann.js"
-export * from "./vcf.csq.js"
-export * from "./vcf.info.js"
-export * from "./vcf.js"
-export * from "./vcf.type.js"

package/src/joinUrl.js

@@ -1,14 +0,0 @@
-function joinUrl(p1, ...p2) {
-	if (typeof p1 != "string") throw `first argument must be string type`
-	if (!p1) throw "blank string not allowed"
-	if (p1.indexOf("?") != -1) throw "search string not allowed"
-	let url = p1
-	for (const p of p2) {
-		if (typeof p != "string") throw `all arguments must be string type`
-		if (!p) throw "blank string not allowed"
-		if (url.slice(-1) != "/") url += "/"
-		url += p.startsWith("/") ? p.substring(1) : p
-	}
-	return url
-}
-export { joinUrl }

package/src/mds3tk.js

@@ -1,100 +0,0 @@
-import { dtcnv, dtsnvindel, dtsv, dtfusionrna } from "./common.js"
-
-// this script should contain mds3 track-related stuff shared between client and backend
-
-/*
-the separator is used to join essential bits of a variant obj into a string as the "ssm_id", aims to uniquely identify a variant irrespective of sample
-this is to mimic the GDC "ssm_id" which is a random id, with below benefits:
-- consistent way to pass request body for both gdc and non-gdc
-- uniform identification of ssm/cnv/sv in non-gdc backend code
-- uniform identification of all variants in client
-
-ssm: chr + pos + ref + alt
-cnv:  chr + start + stop + class
-svfusion: dt + chr + pos + strand + pairlstidx + mname
-
-the separator must avoid conflicting with characters from gene names, and can be changed based on needs
-*/
-export const ssmIdFieldsSeparator = "__"
-
-/*
-input: array of mixture of ssm, svfusion and cnv
-
-output: sorted array. each element: [ class/dt, count of m ]
-*/
-export function summarize_mclass(mlst) {
-	const m2c = new Map() // k: mclass, v: {}
-	const cnvs = []
-	for (const m of mlst) {
-		if (m.dt == dtcnv) {
-			cnvs.push(m)
-			continue // process cnv later
-		}
-		// snvindel has m.class=str, svfusion has only dt=int
-		const key = m.class || m.dt
-		m2c.set(key, 1 + (m2c.get(key) || 0))
-	}
-
-	if (cnvs.length) {
-		if (Number.isFinite(cnvs[0].value)) {
-			// first cnv uses numeric value (assumes all the same). record by dt
-			m2c.set(dtcnv, cnvs.length)
-		} else {
-			// cnv not numeric and uses class; record by each class
-			for (const c of cnvs) {
-				if (!c.class) continue // should not happen
-				m2c.set(c.class, 1 + (m2c.get(c.class) || 0))
-			}
-		}
-	}
-	return [...m2c].sort((i, j) => j[1] - i[1])
-}
-
-/*
-ssmid is not specific for ssm, it covers all alterations
-gdc ssm are identified by a specific uuid, thus the design
-*/
-export function guessSsmid(ssmid) {
-	const l = ssmid.split(ssmIdFieldsSeparator)
-	if (l.length == 4) {
-		const [chr, tmp, ref, alt] = l
-		const pos = Number(tmp)
-		if (Number.isNaN(pos)) throw "ssmid snvindel pos not integer"
-		return { dt: dtsnvindel, l: [chr, pos, ref, alt] }
-	}
-	if (l.length == 5) {
-		// cnv. if type=cat, _value is blank string
-		const [chr, _start, _stop, _class, _value] = l
-		const start = Number(_start),
-			stop = Number(_stop),
-			value = _value == "" ? null : Number(_value)
-		if (Number.isNaN(start) || Number.isNaN(stop))
-			throw "ssmid cnv start/stop not integer"
-		return { dt: dtcnv, l: [chr, start, stop, _class, value] }
-	}
-	if (l.length == 6) {
-		if (l[3] == "+" || l[3] == "-") {
-			// sv/fusion
-			const [_dt, chr, _pos, strand, _pi, _mname] = l
-
-			// mname is encoded in case it contains comma (and is same as ssmIdFieldsSeparator)
-			const mname = decodeURIComponent(_mname)
-			const dt = Number(_dt)
-			if (dt != dtsv && dt != dtfusionrna) throw "ssmid dt not sv/fusion"
-			const pos = Number(_pos)
-			if (Number.isNaN(pos)) throw "ssmid svfusion position not integer"
-			const pairlstIdx = Number(_pi)
-			if (Number.isNaN(pairlstIdx)) throw "ssmid pairlstIdx not integer"
-			return { dt, l: [dt, chr, pos, strand, pairlstIdx, mname] }
-		}
-		// cnv with sample
-		const [chr, _start, _stop, _class, _value, sample] = l
-		const start = Number(_start),
-			stop = Number(_stop),
-			value = _value == "" ? null : Number(_value) // if cnv not using value, must avoid `Number('')=0`
-		if (Number.isNaN(start) || Number.isNaN(stop))
-			throw "ssmid cnv start/stop not integer"
-		return { dt: dtcnv, l: [chr, start, stop, _class, value, sample] }
-	}
-	throw "unknown ssmid"
-}

package/src/roundValue.js

@@ -1,94 +0,0 @@
-/*
-round a value to specified digits
-    - if value is integer, value is returned
-    - if value is a fractional float, round to precision
-    - if value is not a fractional float, round to decimal point
-    - TODO: handle scientific notation
-value: given value
-digits: number of digits to round to
-*/
-
-export function roundValue(value, digits) {
-	const v = Number(value)
-	if (Number.isInteger(v)) return v
-	if (Math.abs(v) < 1) return Number(v.toPrecision(digits))
-	return Number(v.toFixed(digits))
-}
-
-/** Rounds numbers to the appropriate decimal point
- * if format is true, returns either a number or string in
- * scientific notation.
- *
- * TODO: Review digit logic.
- */
-
-export function roundValueAuto(value, format = false, defaultDigits = 2) {
-	if (!value && value != 0) return value
-	const dp = decimalPlacesUntilFirstNonZero(value)
-	const digits =
-		Math.abs(value) > 1 ? defaultDigits : dp > 0 ? dp + 1 : defaultDigits
-	if (format) return formatValue(value, digits)
-	return roundValue(value, digits)
-}
-
-export function decimalPlacesUntilFirstNonZero(number) {
-	// Convert number to string
-	const numberStr = number.toString()
-
-	// Find the position of the decimal point
-	const decimalIndex = numberStr.indexOf(".")
-
-	// If decimal point is not found or number is an integer, return 0
-	if (decimalIndex === -1 || decimalIndex === numberStr.length - 1) {
-		return 0
-	}
-
-	// Iterate through characters after the decimal point
-	let decimalPlaces = 0
-	for (let i = decimalIndex + 1; i < numberStr.length; i++) {
-		// Increment the count of decimal places until a non-zero digit is found
-		if (numberStr[i] === "0") {
-			decimalPlaces++
-		} else if (numberStr[i] >= "1" && numberStr[i] <= "9") {
-			break
-		}
-	}
-
-	return decimalPlaces
-}
-
-/* 
-simple logic to return a number close to original while rounding up decimals.
-supplements roundValueAuto which rounds 12345 to 1.2e4 which is only suitable for human quick glance but not subsequent computing
-
-TODO:
-10000 and 10001 to 1e4
-0.00001 to 1e-5
-1.00001 to 1
-*/
-export function roundValue2(value) {
-	if (!Number.isFinite(value)) return value // not a number
-	if (Number.isInteger(value)) return value // is integer, do not convert
-	const abs = Math.abs(value)
-	if (abs > 100) return Math.round(value) // 12345.1234 to 12345 (compared to 1.2e4 from roundValueAuto)
-	if (abs > 10) return Number(value.toFixed(1)) // 99.1234 to 99.1
-	if (abs > 1) return Number(value.toFixed(2)) // 9.1234 to 9.12
-	if (abs > 0.1) return Number(value.toFixed(3)) // 0.12345 to 0.123
-	if (abs > 0.01) return Number(value.toFixed(4)) // 0.012345 to 0.0123
-	return value // as is
-}
-
-/** Use to return displayed values in scientific notation
- * Do not use for values intended for calculation later.
- */
-export function formatValue(value, digits) {
-	const v = Number(value)
-	if (Number.isInteger(v)) return v
-	const abs = Math.abs(v)
-	if (abs < 1 || abs > 9999) {
-		//Number() reverts positive values less than 10^21 to a whole number
-		//To return the value in scientific notation, use toPrecision without Number()
-		return abs > 9999 ? v.toPrecision(digits) : Number(v.toPrecision(digits))
-	}
-	return Number(v.toFixed(digits))
-}

package/src/termdb.bins.js

@@ -1,456 +0,0 @@
-import { format } from "d3-format"
-import { getColors } from "./common.js"
-import { isNumeric, isStrictNumeric, convertUnits } from "./helpers.js"
-
-export default function validate_bins(binconfig) {
-	// Number.isFinite('1') returns false, which is desired
-
-	const bc = binconfig
-	if (!bc || typeof bc !== "object") throw "bin schema must be an object"
-	// assign default type
-	if (!("type" in bc)) bc.type = "regular-bin"
-
-	if (bc.type == "custom-bin") {
-		if (!Array.isArray(bc.lst)) throw "binconfig.lst must be an array"
-		if (!bc.lst.length) throw "binconfig.lst must have entries"
-		const first_bin = bc.lst[0]
-		const last_bin = bc.lst[bc.lst.length - 1]
-
-		for (const bin of bc.lst) {
-			if (!("startinclusive" in bin) && !("stopinclusive" in bin)) {
-				throw "custom bin.startinclusive and/or bin.stopinclusive must be defined"
-			}
-
-			if (bin == first_bin) {
-				if ("startunbounded" in bin && !bin.startunbounded) {
-					throw `a custom first bin must not set bin.startunbounded to false`
-				}
-				bin.startunbounded = true
-				if ("start" in bin) {
-					throw "a custom first bin must not set a bin.start value"
-				}
-				if ("start_percentile" in bin) {
-					throw "the first bin must not set a bin.start_percentile value"
-				}
-				if (!("stop" in bin)) {
-					throw `a custom first bin must define a bin.stop value`
-				}
-				if (!isStrictNumeric(bin.stop)) {
-					throw `a custom first bin.stop value should be numeric`
-				}
-			} else if (bin == last_bin) {
-				if (!("start" in bin)) {
-					throw `a custom last bin must define a bin.start value`
-				}
-				if (!isStrictNumeric(bin.start)) {
-					throw `a custom last bin.start must be numeric`
-				}
-				if ("stopunbounded" in bin && !bin.stopunbounded) {
-					throw "a custom last bin must not set bin.stopunbounded to false"
-				}
-				bin.stopunbounded = true
-				if ("stop" in bin) {
-					throw "a custom last bin must not set a bin.stop value"
-				}
-			} else {
-				if (bin.startunbounded || bin.stopunbounded) {
-					throw "bin.startunbounded and bin.stopunbounded must not be set for non-first/non-last bins"
-				}
-				if (!isStrictNumeric(bin.start))
-					throw "bin.start must be numeric for a non-first bin"
-				if (!isStrictNumeric(bin.stop))
-					throw "bin.stop must be numeric for a non-last bin"
-			}
-		}
-	} else if (bc.type == "regular-bin") {
-		// required custom_bin parameter
-		if (!Number.isFinite(bc.bin_size)) throw "non-numeric bin_size"
-		if (bc.bin_size <= 0) throw "bin_size must be greater than 0"
-
-		if (!bc.startinclusive && !bc.stopinclusive) {
-			bc.startinclusive = 1
-			bc.stopinclusive = 0
-		}
-
-		if (!bc.first_bin) throw "first_bin{} missing"
-		if (typeof bc.first_bin != "object") throw "first_bin{} is not an object"
-		if (!Object.keys(bc.first_bin).length) throw "first_bin is an empty object"
-
-		{
-			const b = bc.first_bin
-			b.startunbounded = true
-			// requires stop_percentile, or stop
-			if (b.stop_percentile) {
-				if (!Number.isInteger(b.stop_percentile))
-					throw "first_bin.stop_percentile should be integer"
-				if (b.stop_percentile <= 0 || b.stop_percentile >= 100)
-					throw "first_bin.stop_percentile out of bound (0-100)"
-			} else if (!Number.isFinite(b.stop)) {
-				throw "first_bin.stop not a number when stop_percentile is not set"
-			}
-		}
-
-		if (bc.last_bin) {
-			const b = bc.last_bin
-			// requires start_percentile or start
-			if (b.start_percentile) {
-				if (!Number.isInteger(b.start_percentile))
-					throw "last_bin.start_percentile should be integer"
-				if (b.start_percentile <= 0 || b.start_percentile >= 100)
-					throw "last_bin.start_percentile out of bound (0-100)"
-			} else if (!Number.isFinite(b.start)) {
-				throw "last_bin.start not a number when start_percentile is not set"
-			}
-
-			b.stopunbounded = true
-			if ("stop" in b) {
-				throw "a regular last bin must not set a bin.stop value"
-			}
-		}
-	} else {
-		throw `invalid binconfig.type="${bc.type}"`
-	}
-}
-
-export function compute_bins(binconfig, summaryfxn, valueConversion) {
-	/*
-  Bins generator
-  
-binconfig   
-  configuration of bins per the Numerical Binning Scheme
-
-summaryfxn (percentiles)=> return {min, max, pX, pY, ...}
-  - required function
-
-  - must accept an array of desired percentile values
-  and returns an object of computed properties
-  {
-    min: minimum value
-    max: maximum value
-    pX: percentile at X value, so p10 will be 10th percentile value
-    pY: .. corresponding to the desired percentile values 
-  }
-*/
-	const bc = binconfig
-
-	validate_bins(bc)
-	if (bc.lst) {
-		const k2c = getColors(bc.lst.length) //to color bins
-		for (const bin of bc.lst) bin.color = k2c(bin.label)
-	}
-	if (bc.type == "custom-bin") return JSON.parse(JSON.stringify(bc.lst))
-	if (typeof summaryfxn != "function")
-		throw "summaryfxn required for modules/termdb.bins.js compute_bins()"
-	const percentiles = target_percentiles(bc)
-	const summary = summaryfxn(percentiles)
-	if (!summary || typeof summary !== "object")
-		throw "invalid returned value by summaryfxn"
-	bc.results = { summary }
-	if (!bc.binLabelFormatter) bc.binLabelFormatter = getNumDecimalsFormatter(bc)
-
-	// round the min and max values for use as bin start and stop
-	// in the first and last bins, respectively
-	const minFloor = Math.floor(summary.min * 100) / 100
-	const maxCeil = Math.ceil(summary.max * 100) / 100
-	const min = bc.first_bin.startunbounded
-		? minFloor
-		: bc.first_bin.start_percentile
-		? summary["p" + bc.first_bin.start_percentile]
-		: bc.first_bin.start
-	let max = maxCeil, // in order to include the max value in the last bin
-		last_start,
-		last_stop
-
-	if (bc.last_bin) {
-		max = bc.last_bin.stopunbounded
-			? maxCeil // in order to include the max value in the last bin
-			: bc.last_bin.stop_percentile
-			? summary["p" + bc.last_bin.stop_percentile]
-			: isNumeric(bc.last_bin.stop) && bc.last_bin.stop <= summary.max // '0.0088' < 0.0088
-			? bc.last_bin.stop
-			: maxCeil // in order to include the max value in the last bin
-		last_start = isStrictNumeric(bc.last_bin.start_percentile)
-			? summary["p" + bc.last_bin.start_percentile]
-			: isStrictNumeric(bc.last_bin.start)
-			? bc.last_bin.start
-			: undefined
-		last_stop = bc.last_bin.stopunbounded
-			? null
-			: bc.last_bin.stop_percentile
-			? summary["p" + bc.last_bin.stop_percentile]
-			: isStrictNumeric(bc.last_bin.stop)
-			? bc.last_bin.stop
-			: null
-	} else if (bc.lst) {
-		const last_bin = bc.lst[bc.lst.length - 1]
-		last_start = last_bin.start
-		last_stop =
-			"stop" in last_bin && !last_bin.stopunbounded ? last_bin.stop : maxCeil
-		max = last_stop
-	} else {
-		last_start = maxCeil
-		last_stop = maxCeil
-	}
-
-	const numericMax = isStrictNumeric(max)
-	const numericLastStart = isStrictNumeric(last_start)
-	const numericLastStop = isStrictNumeric(last_stop)
-
-	if (!numericMax && !numericLastStart) return [] //throw 'unable to compute the last bin start or stop'
-
-	const bins = []
-	let currBin = {
-		startunbounded: bc.first_bin.startunbounded,
-		start: bc.first_bin.startunbounded ? undefined : min,
-		stop: isStrictNumeric(bc.first_bin.stop_percentile)
-			? +summary["p" + bc.first_bin.stop_percentile]
-			: isStrictNumeric(bc.first_bin.stop)
-			? +bc.first_bin.stop
-			: min + bc.bin_size,
-		startinclusive: bc.startinclusive,
-		stopinclusive: bc.stopinclusive,
-	}
-
-	if (!isStrictNumeric(currBin.stop))
-		throw "the computed first_bin.stop is non-numeric" + currBin.stop
-	const maxNumBins = 100 // harcoded limit for now to not stress sqlite
-
-	while (
-		(numericMax && currBin.stop <= max) ||
-		(currBin.startunbounded && !bins.length) ||
-		currBin.stopunbounded
-	) {
-		bins.push(currBin)
-		// force a computed last bin to have stopunbounded true
-		if (currBin.stop >= max) {
-			currBin.stopunbounded = true
-			if (bins.length > 1) {
-				delete currBin.stop
-			}
-		}
-		currBin.label = get_bin_label(currBin, bc, valueConversion)
-		if (currBin.stopunbounded) break
-
-		const upper = currBin.stop + bc.bin_size
-		const previousStop = currBin.stop
-		currBin = {
-			startinclusive: bc.startinclusive,
-			stopinclusive: bc.stopinclusive,
-			start: previousStop,
-			stop:
-				numericLastStop && (previousStop == last_start || upper > last_stop)
-					? last_stop
-					: numericLastStart && upper > last_start && previousStop != last_start
-					? last_start
-					: upper,
-		}
-
-		if (currBin.stop >= max) {
-			currBin.stop = max
-			if (bc.last_bin && bc.last_bin.stopunbounded) currBin.stopunbounded = 1
-			if (bc.last_bin && bc.last_bin.stopinclusive) currBin.stopinclusive = 1
-		}
-		if (numericLastStart && currBin.start == last_start) {
-			if (bc.last_bin && bc.last_bin.stopunbounded) currBin.stopunbounded = 1
-		}
-		if (currBin.start > currBin.stop) {
-			if (
-				numericLastStart &&
-				currBin.stop == last_start &&
-				bc.last_bin &&
-				bc.last_bin.stopunbounded
-			)
-				currBin.stopunbounded = true
-			else break
-		}
-		if (bins.length + 1 >= maxNumBins) {
-			bc.error = "max_num_bins_reached"
-			break
-		}
-	}
-	delete bc.binLabelFormatter
-	if (bins.length > 1) {
-		delete bins[bins.length - 1].stop
-	}
-	const k2c = getColors(bins.length) //to color bins
-	for (const bin of bins) bin.color = k2c(bin.label)
-	return bins
-}
-
-function getNumDecimalsFormatter(bc) {
-	//return format('rounding' in bc ? bc.rounding : '')
-	return "rounding" in bc ? format(bc.rounding) : (d) => d // default to labeling using the start/stop value as-is
-}
-
-export function get_bin_label(bin, binconfig, valueConversion) {
-	/*
-  Generate a numeric bin label given a bin configuration and an optional term valueConversion object
-*/
-	if (!bin) return "missing bin.label"
-	if (bin.label) return bin.label
-
-	const bc = binconfig
-	if (!bc.binLabelFormatter) bc.binLabelFormatter = getNumDecimalsFormatter(bc)
-	if (
-		!bin.startunbounded &&
-		!bin.stopunbounded &&
-		!("startinclusive" in bin) &&
-		!("stopinclusive" in bin)
-	) {
-		if (bc.startinclusive) bin.startinclusive = true
-		else if (bc.stopinclusive) bin.stopinclusive = true
-	}
-
-	const start = bc.use_as == "bins" || bin.start
-	const stop = bc.use_as == "bins" || bin.stop
-
-	let label_offset = 0
-	if ("label_offset" in bc) {
-		bc.label_offset_ignored = "bin_size" in bc && bc.bin_size < bc.label_offset
-		if (!bc.label_offset_ignored) label_offset = bc.label_offset
-	} else if (bc.bin_size === 1 && bc.termtype == "integer") {
-		label_offset = 1
-	}
-
-	// one side-unbounded bins
-	// label will be ">v" or "<v"
-	if (bin.startunbounded) {
-		const oper = bin.stopinclusive ? "≤" : "<" // \u2264
-		const v1 = valueConversion
-			? convertUnits(
-					stop,
-					valueConversion.fromUnit,
-					valueConversion.toUnit,
-					valueConversion.scaleFactor,
-					true
-			  )
-			: bc.binLabelFormatter(stop) //bin.startinclusive && label_offset ? stop - label_offset : stop)
-		return oper + v1
-	}
-	// a data value may coincide with the last bin's start
-	if (bin.stopunbounded || start === stop) {
-		const oper = bin.startinclusive /*|| label_offset*/ ? "≥" : ">" // \u2265
-		const v0 = valueConversion
-			? convertUnits(
-					start,
-					valueConversion.fromUnit,
-					valueConversion.toUnit,
-					valueConversion.scaleFactor,
-					true
-			  )
-			: bc.binLabelFormatter(start) //bin.startinclusive || start == min ? start : start + label_offset)
-		return oper + v0
-	}
-
-	// two-sided bins
-	if (label_offset && bin.startinclusive && !bin.stopinclusive) {
-		if (
-			Number.isInteger(bc.bin_size) &&
-			Math.abs(start - stop) === label_offset
-		) {
-			// make a simpler label when the range simply spans the bin_size
-			return (
-				"" +
-				(valueConversion
-					? convertUnits(
-							start,
-							valueConversion.fromUnit,
-							valueConversion.toUnit,
-							valueConversion.scaleFactor,
-							true
-					  )
-					: bc.binLabelFormatter(start))
-			)
-		} else {
-			const v0 = valueConversion
-				? convertUnits(
-						start,
-						valueConversion.fromUnit,
-						valueConversion.toUnit,
-						valueConversion.scaleFactor,
-						true
-				  )
-				: bc.binLabelFormatter(start)
-			const v1 = valueConversion
-				? convertUnits(
-						stop - label_offset,
-						valueConversion.fromUnit,
-						valueConversion.toUnit,
-						valueConversion.scaleFactor,
-						true
-				  )
-				: bc.binLabelFormatter(stop - label_offset)
-			// ensure that last two bin labels make sense (the last is stopunbounded)
-			return +v0 >= +v1 ? v0.toString() : v0 + " to " + v1
-		}
-	} else {
-		// stop_inclusive || label_offset == 0
-		const oper0 = bin.startinclusive ? "" : ">"
-		const oper1 = bin.stopinclusive ? "" : "<"
-		const v0 = valueConversion
-			? convertUnits(
-					start,
-					valueConversion.fromUnit,
-					valueConversion.toUnit,
-					valueConversion.scaleFactor,
-					true
-			  )
-			: Number.isInteger(start)
-			? start
-			: bc.binLabelFormatter(start)
-		const v1 = valueConversion
-			? convertUnits(
-					stop,
-					valueConversion.fromUnit,
-					valueConversion.toUnit,
-					valueConversion.scaleFactor,
-					true
-			  )
-			: Number.isInteger(stop)
-			? stop
-			: bc.binLabelFormatter(stop)
-		// after rounding the bin labels, the bin start may equal the last bin stop as derived from actual data
-		if (+v0 >= +v1) {
-			const oper = bin.startinclusive ? "≥" : ">" // \u2265
-			return oper + v0
-		} else {
-			return oper0 + v0 + " to " + oper1 + v1
-		}
-	}
-}
-
-// get bin range equation from bin label and bin properties
-export function get_bin_range_equation(bin, binconfig) {
-	const x = '<span style="font-family:Times;font-style:italic;">x</span>'
-	let range_eq
-	// should always use computed (not user-customized) bin label to determine bin range text
-	const copy = structuredClone(bin)
-	copy.label = "" // mutate only the copy, and not the original bin argument
-	const bin_label = get_bin_label(copy, binconfig)
-	if (bin.startunbounded || bin.stopunbounded) {
-		// first or last bins, e.g. x ≤ 14 and x > 16
-		range_eq = x + " " + bin_label
-	} else if (bin.startinclusive) {
-		// bins with startinclusive, e.g. 14 ≤ x < 16
-		range_eq = bin_label.replace("to <", "≤ " + x + " <")
-	} else if (bin.stopinclusive) {
-		// bins with stopinclusive, e.g. 14 < x ≤ 16
-		range_eq = bin_label.replace(">", "").replace("to", "< " + x + " ≤")
-	}
-	return range_eq
-}
-
-export function target_percentiles(binconfig) {
-	const percentiles = []
-	const f = binconfig.first_bin
-	if (f && isStrictNumeric(f.start_percentile))
-		percentiles.push(f.start_percentile)
-	if (f && isStrictNumeric(f.stop_percentile))
-		percentiles.push(f.stop_percentile)
-	const l = binconfig.last_bin
-	if (l && isStrictNumeric(l.start_percentile))
-		percentiles.push(l.start_percentile)
-	if (l && isStrictNumeric(l.stop_percentile))
-		percentiles.push(l.stop_percentile)
-	return percentiles
-}