{"version":3,"file":"js/344-83e81cff9902dee035bf.chunk.js","mappings":"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","sources":["webpack://chemotion/../../cache/node_modules/d3-array/src/greatest.js","webpack://chemotion/../../cache/node_modules/d3-array/src/cross.js","webpack://chemotion/../../cache/node_modules/d3-array/src/cumsum.js","webpack://chemotion/../../cache/node_modules/d3-array/src/variance.js","webpack://chemotion/../../cache/node_modules/d3-array/src/deviation.js","webpack://chemotion/../../cache/node_modules/d3-array/src/identity.js","webpack://chemotion/../../cache/node_modules/d3-array/src/group.js","webpack://chemotion/../../cache/node_modules/d3-array/src/groupSort.js","webpack://chemotion/../../cache/node_modules/d3-array/src/array.js","webpack://chemotion/../../cache/node_modules/d3-array/src/constant.js","webpack://chemotion/../../cache/node_modules/d3-array/src/bin.js","webpack://chemotion/../../cache/node_modules/d3-array/src/threshold/freedmanDiaconis.js","webpack://chemotion/../../cache/node_modules/d3-array/src/threshold/scott.js","webpack://chemotion/../../cache/node_modules/d3-array/src/mean.js","webpack://chemotion/../../cache/node_modules/d3-array/src/median.js","webpack://chemotion/../../cache/node_modules/d3-array/src/mode.js","webpack://chemotion/../../cache/node_modules/d3-array/src/pairs.js","webpack://chemotion/../../cache/node_modules/d3-array/src/rank.js","webpack://chemotion/../../cache/node_modules/d3-array/src/least.js","webpack://chemotion/../../cache/node_modules/d3-array/src/leastIndex.js","webpack://chemotion/../../cache/node_modules/d3-array/src/greatestIndex.js","webpack://chemotion/../../cache/node_modules/d3-array/src/scan.js","webpack://chemotion/../../cache/node_modules/d3-array/src/shuffle.js","webpack://chemotion/../../cache/node_modules/d3-array/src/sum.js","webpack://chemotion/../../cache/node_modules/d3-array/src/transpose.js","webpack://chemotion/../../cache/node_modules/d3-array/src/zip.js","webpack://chemotion/../../cache/node_modules/d3-array/src/every.js","webpack://chemotion/../../cache/node_modules/d3-array/src/some.js","webpack://chemotion/../../cache/node_modules/d3-array/src/filter.js","webpack://chemotion/../../cache/node_modules/d3-array/src/map.js","webpack://chemotion/../../cache/node_modules/d3-array/src/reduce.js","webpack://chemotion/../../cache/node_modules/d3-array/src/reverse.js","webpack://chemotion/../../cache/node_modules/d3-array/src/difference.js","webpack://chemotion/../../cache/node_modules/d3-array/src/disjoint.js","webpack://chemotion/../../cache/node_modules/d3-array/src/intersection.js","webpack://chemotion/../../cache/node_modules/d3-array/src/superset.js","webpack://chemotion/../../cache/node_modules/d3-array/src/subset.js","webpack://chemotion/../../cache/node_modules/d3-array/src/union.js","webpack://chemotion/../../cache/node_modules/d3-array/src/maxIndex.js","webpack://chemotion/../../cache/node_modules/d3-array/src/merge.js","webpack://chemotion/../../cache/node_modules/d3-array/src/min.js","webpack://chemotion/../../cache/node_modules/d3-array/src/minIndex.js","webpack://chemotion/../../cache/node_modules/d3-array/src/permute.js","webpack://chemotion/../../cache/node_modules/d3-array/src/quantile.js","webpack://chemotion/../../cache/node_modules/d3-array/src/quickselect.js","webpack://chemotion/../../cache/node_modules/d3-array/src/sort.js","webpack://chemotion/../../cache/node_modules/d3-color/src/cubehelix.js","webpack://chemotion/../../cache/node_modules/d3-color/src/lab.js","webpack://chemotion/../../cache/node_modules/d3-color/src/math.js","webpack://chemotion/../../cache/node_modules/d3-hierarchy/src/cluster.js","webpack://chemotion/../../cache/node_modules/d3-hierarchy/src/stratify.js","webpack://chemotion/../../cache/node_modules/d3-hierarchy/src/tree.js","webpack://chemotion/../../cache/node_modules/d3-interpolate/src/cubehelix.js","webpack://chemotion/../../cache/node_modules/d3-interpolate/src/discrete.js","webpack://chemotion/../../cache/node_modules/d3-interpolate/src/hue.js","webpack://chemotion/../../cache/node_modules/d3-interpolate/src/hsl.js","webpack://chemotion/../../cache/node_modules/d3-interpolate/src/lab.js","webpack://chemotion/../../cache/node_modules/d3-interpolate/src/hcl.js","webpack://chemotion/../../cache/node_modules/d3-interpolate/src/quantize.js","webpack://chemotion/../../cache/node_modules/d3-interpolate/src/piecewise.js","webpack://chemotion/../../cache/node_modules/d3-scale/src/identity.js","webpack://chemotion/../../cache/node_modules/d3-scale/src/symlog.js","webpack://chemotion/../../cache/node_modules/d3-scale/src/radial.js","webpack://chemotion/../../cache/node_modules/d3-scale/src/quantile.js","webpack://chemotion/../../cache/node_modules/d3-scale/src/quantize.js","webpack://chemotion/../../cache/node_modules/d3-scale/src/threshold.js","webpack://chemotion/../../cache/node_modules/d3-scale/src/sequential.js","webpack://chemotion/../../cache/node_modules/d3-scale/src/sequentialQuantile.js","webpack://chemotion/../../cache/node_modules/d3-scale/src/diverging.js","webpack://chemotion/../../cache/node_modules/d3-selection/src/create.js","webpack://chemotion/../../cache/node_modules/d3-selection/src/local.js","webpack://chemotion/../../cache/node_modules/d3-selection/src/pointers.js","webpack://chemotion/../../cache/node_modules/d3-selection/src/selectAll.js","webpack://chemotion/../../cache/node_modules/robust-predicates/esm/util.js","webpack://chemotion/../../cache/node_modules/robust-predicates/esm/orient2d.js","webpack://chemotion/../../cache/node_modules/robust-predicates/esm/orient3d.js","webpack://chemotion/../../cache/node_modules/robust-predicates/esm/incircle.js","webpack://chemotion/../../cache/node_modules/robust-predicates/esm/insphere.js"],"sourcesContent":["import ascending from \"./ascending.js\";\n\nexport default function greatest(values, compare = ascending) {\n  let max;\n  let defined = false;\n  if (compare.length === 1) {\n    let maxValue;\n    for (const element of values) {\n      const value = compare(element);\n      if (defined\n          ? ascending(value, maxValue) > 0\n          : ascending(value, value) === 0) {\n        max = element;\n        maxValue = value;\n        defined = true;\n      }\n    }\n  } else {\n    for (const value of values) {\n      if (defined\n          ? compare(value, max) > 0\n          : compare(value, value) === 0) {\n        max = value;\n        defined = true;\n      }\n    }\n  }\n  return max;\n}\n","function length(array) {\n  return array.length | 0;\n}\n\nfunction empty(length) {\n  return !(length > 0);\n}\n\nfunction arrayify(values) {\n  return typeof values !== \"object\" || \"length\" in values ? values : Array.from(values);\n}\n\nfunction reducer(reduce) {\n  return values => reduce(...values);\n}\n\nexport default function cross(...values) {\n  const reduce = typeof values[values.length - 1] === \"function\" && reducer(values.pop());\n  values = values.map(arrayify);\n  const lengths = values.map(length);\n  const j = values.length - 1;\n  const index = new Array(j + 1).fill(0);\n  const product = [];\n  if (j < 0 || lengths.some(empty)) return product;\n  while (true) {\n    product.push(index.map((j, i) => values[i][j]));\n    let i = j;\n    while (++index[i] === lengths[i]) {\n      if (i === 0) return reduce ? product.map(reduce) : product;\n      index[i--] = 0;\n    }\n  }\n}\n","export default function cumsum(values, valueof) {\n  var sum = 0, index = 0;\n  return Float64Array.from(values, valueof === undefined\n    ? v => (sum += +v || 0)\n    : v => (sum += +valueof(v, index++, values) || 0));\n}","export default function variance(values, valueof) {\n  let count = 0;\n  let delta;\n  let mean = 0;\n  let sum = 0;\n  if (valueof === undefined) {\n    for (let value of values) {\n      if (value != null && (value = +value) >= value) {\n        delta = value - mean;\n        mean += delta / ++count;\n        sum += delta * (value - mean);\n      }\n    }\n  } else {\n    let index = -1;\n    for (let value of values) {\n      if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {\n        delta = value - mean;\n        mean += delta / ++count;\n        sum += delta * (value - mean);\n      }\n    }\n  }\n  if (count > 1) return sum / (count - 1);\n}\n","import variance from \"./variance.js\";\n\nexport default function deviation(values, valueof) {\n  const v = variance(values, valueof);\n  return v ? Math.sqrt(v) : v;\n}\n","export default function identity(x) {\n  return x;\n}\n","import {InternMap} from \"internmap\";\nimport identity from \"./identity.js\";\n\nexport default function group(values, ...keys) {\n  return nest(values, identity, identity, keys);\n}\n\nexport function groups(values, ...keys) {\n  return nest(values, Array.from, identity, keys);\n}\n\nfunction flatten(groups, keys) {\n  for (let i = 1, n = keys.length; i < n; ++i) {\n    groups = groups.flatMap(g => g.pop().map(([key, value]) => [...g, key, value]));\n  }\n  return groups;\n}\n\nexport function flatGroup(values, ...keys) {\n  return flatten(groups(values, ...keys), keys);\n}\n\nexport function flatRollup(values, reduce, ...keys) {\n  return flatten(rollups(values, reduce, ...keys), keys);\n}\n\nexport function rollup(values, reduce, ...keys) {\n  return nest(values, identity, reduce, keys);\n}\n\nexport function rollups(values, reduce, ...keys) {\n  return nest(values, Array.from, reduce, keys);\n}\n\nexport function index(values, ...keys) {\n  return nest(values, identity, unique, keys);\n}\n\nexport function indexes(values, ...keys) {\n  return nest(values, Array.from, unique, keys);\n}\n\nfunction unique(values) {\n  if (values.length !== 1) throw new Error(\"duplicate key\");\n  return values[0];\n}\n\nfunction nest(values, map, reduce, keys) {\n  return (function regroup(values, i) {\n    if (i >= keys.length) return reduce(values);\n    const groups = new InternMap();\n    const keyof = keys[i++];\n    let index = -1;\n    for (const value of values) {\n      const key = keyof(value, ++index, values);\n      const group = groups.get(key);\n      if (group) group.push(value);\n      else groups.set(key, [value]);\n    }\n    for (const [key, values] of groups) {\n      groups.set(key, regroup(values, i));\n    }\n    return map(groups);\n  })(values, 0);\n}\n","import ascending from \"./ascending.js\";\nimport group, {rollup} from \"./group.js\";\nimport sort from \"./sort.js\";\n\nexport default function groupSort(values, reduce, key) {\n  return (reduce.length !== 2\n    ? sort(rollup(values, reduce, key), (([ak, av], [bk, bv]) => ascending(av, bv) || ascending(ak, bk)))\n    : sort(group(values, key), (([ak, av], [bk, bv]) => reduce(av, bv) || ascending(ak, bk))))\n    .map(([key]) => key);\n}\n","var array = Array.prototype;\n\nexport var slice = array.slice;\nexport var map = array.map;\n","export default function constant(x) {\n  return () => x;\n}\n","import {slice} from \"./array.js\";\nimport bisect from \"./bisect.js\";\nimport constant from \"./constant.js\";\nimport extent from \"./extent.js\";\nimport identity from \"./identity.js\";\nimport nice from \"./nice.js\";\nimport ticks, {tickIncrement} from \"./ticks.js\";\nimport sturges from \"./threshold/sturges.js\";\n\nexport default function bin() {\n  var value = identity,\n      domain = extent,\n      threshold = sturges;\n\n  function histogram(data) {\n    if (!Array.isArray(data)) data = Array.from(data);\n\n    var i,\n        n = data.length,\n        x,\n        step,\n        values = new Array(n);\n\n    for (i = 0; i < n; ++i) {\n      values[i] = value(data[i], i, data);\n    }\n\n    var xz = domain(values),\n        x0 = xz[0],\n        x1 = xz[1],\n        tz = threshold(values, x0, x1);\n\n    // Convert number of thresholds into uniform thresholds, and nice the\n    // default domain accordingly.\n    if (!Array.isArray(tz)) {\n      const max = x1, tn = +tz;\n      if (domain === extent) [x0, x1] = nice(x0, x1, tn);\n      tz = ticks(x0, x1, tn);\n\n      // If the domain is aligned with the first tick (which it will by\n      // default), then we can use quantization rather than bisection to bin\n      // values, which is substantially faster.\n      if (tz[0] <= x0) step = tickIncrement(x0, x1, tn);\n\n      // If the last threshold is coincident with the domain’s upper bound, the\n      // last bin will be zero-width. If the default domain is used, and this\n      // last threshold is coincident with the maximum input value, we can\n      // extend the niced upper bound by one tick to ensure uniform bin widths;\n      // otherwise, we simply remove the last threshold. Note that we don’t\n      // coerce values or the domain to numbers, and thus must be careful to\n      // compare order (>=) rather than strict equality (===)!\n      if (tz[tz.length - 1] >= x1) {\n        if (max >= x1 && domain === extent) {\n          const step = tickIncrement(x0, x1, tn);\n          if (isFinite(step)) {\n            if (step > 0) {\n              x1 = (Math.floor(x1 / step) + 1) * step;\n            } else if (step < 0) {\n              x1 = (Math.ceil(x1 * -step) + 1) / -step;\n            }\n          }\n        } else {\n          tz.pop();\n        }\n      }\n    }\n\n    // Remove any thresholds outside the domain.\n    // Be careful not to mutate an array owned by the user!\n    var m = tz.length, a = 0, b = m;\n    while (tz[a] <= x0) ++a;\n    while (tz[b - 1] > x1) --b;\n    if (a || b < m) tz = tz.slice(a, b), m = b - a;\n\n    var bins = new Array(m + 1),\n        bin;\n\n    // Initialize bins.\n    for (i = 0; i <= m; ++i) {\n      bin = bins[i] = [];\n      bin.x0 = i > 0 ? tz[i - 1] : x0;\n      bin.x1 = i < m ? tz[i] : x1;\n    }\n\n    // Assign data to bins by value, ignoring any outside the domain.\n    if (isFinite(step)) {\n      if (step > 0) {\n        for (i = 0; i < n; ++i) {\n          if ((x = values[i]) != null && x0 <= x && x <= x1) {\n            bins[Math.min(m, Math.floor((x - x0) / step))].push(data[i]);\n          }\n        }\n      } else if (step < 0) {\n        for (i = 0; i < n; ++i) {\n          if ((x = values[i]) != null && x0 <= x && x <= x1) {\n            const j = Math.floor((x0 - x) * step);\n            bins[Math.min(m, j + (tz[j] <= x))].push(data[i]); // handle off-by-one due to rounding\n          }\n        }\n      }\n    } else {\n      for (i = 0; i < n; ++i) {\n        if ((x = values[i]) != null && x0 <= x && x <= x1) {\n          bins[bisect(tz, x, 0, m)].push(data[i]);\n        }\n      }\n    }\n\n    return bins;\n  }\n\n  histogram.value = function(_) {\n    return arguments.length ? (value = typeof _ === \"function\" ? _ : constant(_), histogram) : value;\n  };\n\n  histogram.domain = function(_) {\n    return arguments.length ? (domain = typeof _ === \"function\" ? _ : constant([_[0], _[1]]), histogram) : domain;\n  };\n\n  histogram.thresholds = function(_) {\n    return arguments.length ? (threshold = typeof _ === \"function\" ? _ : constant(Array.isArray(_) ? slice.call(_) : _), histogram) : threshold;\n  };\n\n  return histogram;\n}\n","import count from \"../count.js\";\nimport quantile from \"../quantile.js\";\n\nexport default function thresholdFreedmanDiaconis(values, min, max) {\n  const c = count(values), d = quantile(values, 0.75) - quantile(values, 0.25);\n  return c && d ? Math.ceil((max - min) / (2 * d * Math.pow(c, -1 / 3))) : 1;\n}\n","import count from \"../count.js\";\nimport deviation from \"../deviation.js\";\n\nexport default function thresholdScott(values, min, max) {\n  const c = count(values), d = deviation(values);\n  return c && d ? Math.ceil((max - min) * Math.cbrt(c) / (3.49 * d)) : 1;\n}\n","export default function mean(values, valueof) {\n  let count = 0;\n  let sum = 0;\n  if (valueof === undefined) {\n    for (let value of values) {\n      if (value != null && (value = +value) >= value) {\n        ++count, sum += value;\n      }\n    }\n  } else {\n    let index = -1;\n    for (let value of values) {\n      if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {\n        ++count, sum += value;\n      }\n    }\n  }\n  if (count) return sum / count;\n}\n","import quantile, {quantileIndex} from \"./quantile.js\";\n\nexport default function median(values, valueof) {\n  return quantile(values, 0.5, valueof);\n}\n\nexport function medianIndex(values, valueof) {\n  return quantileIndex(values, 0.5, valueof);\n}\n","import {InternMap} from \"internmap\";\n\nexport default function mode(values, valueof) {\n  const counts = new InternMap();\n  if (valueof === undefined) {\n    for (let value of values) {\n      if (value != null && value >= value) {\n        counts.set(value, (counts.get(value) || 0) + 1);\n      }\n    }\n  } else {\n    let index = -1;\n    for (let value of values) {\n      if ((value = valueof(value, ++index, values)) != null && value >= value) {\n        counts.set(value, (counts.get(value) || 0) + 1);\n      }\n    }\n  }\n  let modeValue;\n  let modeCount = 0;\n  for (const [value, count] of counts) {\n    if (count > modeCount) {\n      modeCount = count;\n      modeValue = value;\n    }\n  }\n  return modeValue;\n}\n","export default function pairs(values, pairof = pair) {\n  const pairs = [];\n  let previous;\n  let first = false;\n  for (const value of values) {\n    if (first) pairs.push(pairof(previous, value));\n    previous = value;\n    first = true;\n  }\n  return pairs;\n}\n\nexport function pair(a, b) {\n  return [a, b];\n}\n","import ascending from \"./ascending.js\";\nimport {ascendingDefined, compareDefined} from \"./sort.js\";\n\nexport default function rank(values, valueof = ascending) {\n  if (typeof values[Symbol.iterator] !== \"function\") throw new TypeError(\"values is not iterable\");\n  let V = Array.from(values);\n  const R = new Float64Array(V.length);\n  if (valueof.length !== 2) V = V.map(valueof), valueof = ascending;\n  const compareIndex = (i, j) => valueof(V[i], V[j]);\n  let k, r;\n  values = Uint32Array.from(V, (_, i) => i);\n  // Risky chaining due to Safari 14 https://github.com/d3/d3-array/issues/123\n  values.sort(valueof === ascending ? (i, j) => ascendingDefined(V[i], V[j]) : compareDefined(compareIndex));\n  values.forEach((j, i) => {\n      const c = compareIndex(j, k === undefined ? j : k);\n      if (c >= 0) {\n        if (k === undefined || c > 0) k = j, r = i;\n        R[j] = r;\n      } else {\n        R[j] = NaN;\n      }\n    });\n  return R;\n}\n","import ascending from \"./ascending.js\";\n\nexport default function least(values, compare = ascending) {\n  let min;\n  let defined = false;\n  if (compare.length === 1) {\n    let minValue;\n    for (const element of values) {\n      const value = compare(element);\n      if (defined\n          ? ascending(value, minValue) < 0\n          : ascending(value, value) === 0) {\n        min = element;\n        minValue = value;\n        defined = true;\n      }\n    }\n  } else {\n    for (const value of values) {\n      if (defined\n          ? compare(value, min) < 0\n          : compare(value, value) === 0) {\n        min = value;\n        defined = true;\n      }\n    }\n  }\n  return min;\n}\n","import ascending from \"./ascending.js\";\nimport minIndex from \"./minIndex.js\";\n\nexport default function leastIndex(values, compare = ascending) {\n  if (compare.length === 1) return minIndex(values, compare);\n  let minValue;\n  let min = -1;\n  let index = -1;\n  for (const value of values) {\n    ++index;\n    if (min < 0\n        ? compare(value, value) === 0\n        : compare(value, minValue) < 0) {\n      minValue = value;\n      min = index;\n    }\n  }\n  return min;\n}\n","import ascending from \"./ascending.js\";\nimport maxIndex from \"./maxIndex.js\";\n\nexport default function greatestIndex(values, compare = ascending) {\n  if (compare.length === 1) return maxIndex(values, compare);\n  let maxValue;\n  let max = -1;\n  let index = -1;\n  for (const value of values) {\n    ++index;\n    if (max < 0\n        ? compare(value, value) === 0\n        : compare(value, maxValue) > 0) {\n      maxValue = value;\n      max = index;\n    }\n  }\n  return max;\n}\n","import leastIndex from \"./leastIndex.js\";\n\nexport default function scan(values, compare) {\n  const index = leastIndex(values, compare);\n  return index < 0 ? undefined : index;\n}\n","export default shuffler(Math.random);\n\nexport function shuffler(random) {\n  return function shuffle(array, i0 = 0, i1 = array.length) {\n    let m = i1 - (i0 = +i0);\n    while (m) {\n      const i = random() * m-- | 0, t = array[m + i0];\n      array[m + i0] = array[i + i0];\n      array[i + i0] = t;\n    }\n    return array;\n  };\n}\n","export default function sum(values, valueof) {\n  let sum = 0;\n  if (valueof === undefined) {\n    for (let value of values) {\n      if (value = +value) {\n        sum += value;\n      }\n    }\n  } else {\n    let index = -1;\n    for (let value of values) {\n      if (value = +valueof(value, ++index, values)) {\n        sum += value;\n      }\n    }\n  }\n  return sum;\n}\n","import min from \"./min.js\";\n\nexport default function transpose(matrix) {\n  if (!(n = matrix.length)) return [];\n  for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {\n    for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {\n      row[j] = matrix[j][i];\n    }\n  }\n  return transpose;\n}\n\nfunction length(d) {\n  return d.length;\n}\n","import transpose from \"./transpose.js\";\n\nexport default function zip() {\n  return transpose(arguments);\n}\n","export default function every(values, test) {\n  if (typeof test !== \"function\") throw new TypeError(\"test is not a function\");\n  let index = -1;\n  for (const value of values) {\n    if (!test(value, ++index, values)) {\n      return false;\n    }\n  }\n  return true;\n}\n","export default function some(values, test) {\n  if (typeof test !== \"function\") throw new TypeError(\"test is not a function\");\n  let index = -1;\n  for (const value of values) {\n    if (test(value, ++index, values)) {\n      return true;\n    }\n  }\n  return false;\n}\n","export default function filter(values, test) {\n  if (typeof test !== \"function\") throw new TypeError(\"test is not a function\");\n  const array = [];\n  let index = -1;\n  for (const value of values) {\n    if (test(value, ++index, values)) {\n      array.push(value);\n    }\n  }\n  return array;\n}\n","export default function map(values, mapper) {\n  if (typeof values[Symbol.iterator] !== \"function\") throw new TypeError(\"values is not iterable\");\n  if (typeof mapper !== \"function\") throw new TypeError(\"mapper is not a function\");\n  return Array.from(values, (value, index) => mapper(value, index, values));\n}\n","export default function reduce(values, reducer, value) {\n  if (typeof reducer !== \"function\") throw new TypeError(\"reducer is not a function\");\n  const iterator = values[Symbol.iterator]();\n  let done, next, index = -1;\n  if (arguments.length < 3) {\n    ({done, value} = iterator.next());\n    if (done) return;\n    ++index;\n  }\n  while (({done, value: next} = iterator.next()), !done) {\n    value = reducer(value, next, ++index, values);\n  }\n  return value;\n}\n","export default function reverse(values) {\n  if (typeof values[Symbol.iterator] !== \"function\") throw new TypeError(\"values is not iterable\");\n  return Array.from(values).reverse();\n}\n","import {InternSet} from \"internmap\";\n\nexport default function difference(values, ...others) {\n  values = new InternSet(values);\n  for (const other of others) {\n    for (const value of other) {\n      values.delete(value);\n    }\n  }\n  return values;\n}\n","import {InternSet} from \"internmap\";\n\nexport default function disjoint(values, other) {\n  const iterator = other[Symbol.iterator](), set = new InternSet();\n  for (const v of values) {\n    if (set.has(v)) return false;\n    let value, done;\n    while (({value, done} = iterator.next())) {\n      if (done) break;\n      if (Object.is(v, value)) return false;\n      set.add(value);\n    }\n  }\n  return true;\n}\n","import {InternSet} from \"internmap\";\n\nexport default function intersection(values, ...others) {\n  values = new InternSet(values);\n  others = others.map(set);\n  out: for (const value of values) {\n    for (const other of others) {\n      if (!other.has(value)) {\n        values.delete(value);\n        continue out;\n      }\n    }\n  }\n  return values;\n}\n\nfunction set(values) {\n  return values instanceof InternSet ? values : new InternSet(values);\n}\n","export default function superset(values, other) {\n  const iterator = values[Symbol.iterator](), set = new Set();\n  for (const o of other) {\n    const io = intern(o);\n    if (set.has(io)) continue;\n    let value, done;\n    while (({value, done} = iterator.next())) {\n      if (done) return false;\n      const ivalue = intern(value);\n      set.add(ivalue);\n      if (Object.is(io, ivalue)) break;\n    }\n  }\n  return true;\n}\n\nfunction intern(value) {\n  return value !== null && typeof value === \"object\" ? value.valueOf() : value;\n}\n","import superset from \"./superset.js\";\n\nexport default function subset(values, other) {\n  return superset(other, values);\n}\n","import {InternSet} from \"internmap\";\n\nexport default function union(...others) {\n  const set = new InternSet();\n  for (const other of others) {\n    for (const o of other) {\n      set.add(o);\n    }\n  }\n  return set;\n}\n","export default function maxIndex(values, valueof) {\n  let max;\n  let maxIndex = -1;\n  let index = -1;\n  if (valueof === undefined) {\n    for (const value of values) {\n      ++index;\n      if (value != null\n          && (max < value || (max === undefined && value >= value))) {\n        max = value, maxIndex = index;\n      }\n    }\n  } else {\n    for (let value of values) {\n      if ((value = valueof(value, ++index, values)) != null\n          && (max < value || (max === undefined && value >= value))) {\n        max = value, maxIndex = index;\n      }\n    }\n  }\n  return maxIndex;\n}\n","function* flatten(arrays) {\n  for (const array of arrays) {\n    yield* array;\n  }\n}\n\nexport default function merge(arrays) {\n  return Array.from(flatten(arrays));\n}\n","export default function min(values, valueof) {\n  let min;\n  if (valueof === undefined) {\n    for (const value of values) {\n      if (value != null\n          && (min > value || (min === undefined && value >= value))) {\n        min = value;\n      }\n    }\n  } else {\n    let index = -1;\n    for (let value of values) {\n      if ((value = valueof(value, ++index, values)) != null\n          && (min > value || (min === undefined && value >= value))) {\n        min = value;\n      }\n    }\n  }\n  return min;\n}\n","export default function minIndex(values, valueof) {\n  let min;\n  let minIndex = -1;\n  let index = -1;\n  if (valueof === undefined) {\n    for (const value of values) {\n      ++index;\n      if (value != null\n          && (min > value || (min === undefined && value >= value))) {\n        min = value, minIndex = index;\n      }\n    }\n  } else {\n    for (let value of values) {\n      if ((value = valueof(value, ++index, values)) != null\n          && (min > value || (min === undefined && value >= value))) {\n        min = value, minIndex = index;\n      }\n    }\n  }\n  return minIndex;\n}\n","export default function permute(source, keys) {\n  return Array.from(keys, key => source[key]);\n}\n","import max from \"./max.js\";\nimport maxIndex from \"./maxIndex.js\";\nimport min from \"./min.js\";\nimport minIndex from \"./minIndex.js\";\nimport quickselect from \"./quickselect.js\";\nimport number, {numbers} from \"./number.js\";\nimport {ascendingDefined} from \"./sort.js\";\nimport greatest from \"./greatest.js\";\n\nexport default function quantile(values, p, valueof) {\n  values = Float64Array.from(numbers(values, valueof));\n  if (!(n = values.length) || isNaN(p = +p)) return;\n  if (p <= 0 || n < 2) return min(values);\n  if (p >= 1) return max(values);\n  var n,\n      i = (n - 1) * p,\n      i0 = Math.floor(i),\n      value0 = max(quickselect(values, i0).subarray(0, i0 + 1)),\n      value1 = min(values.subarray(i0 + 1));\n  return value0 + (value1 - value0) * (i - i0);\n}\n\nexport function quantileSorted(values, p, valueof = number) {\n  if (!(n = values.length) || isNaN(p = +p)) return;\n  if (p <= 0 || n < 2) return +valueof(values[0], 0, values);\n  if (p >= 1) return +valueof(values[n - 1], n - 1, values);\n  var n,\n      i = (n - 1) * p,\n      i0 = Math.floor(i),\n      value0 = +valueof(values[i0], i0, values),\n      value1 = +valueof(values[i0 + 1], i0 + 1, values);\n  return value0 + (value1 - value0) * (i - i0);\n}\n\nexport function quantileIndex(values, p, valueof = number) {\n  if (isNaN(p = +p)) return;\n  numbers = Float64Array.from(values, (_, i) => number(valueof(values[i], i, values)));\n  if (p <= 0) return minIndex(numbers);\n  if (p >= 1) return maxIndex(numbers);\n  var numbers,\n      index = Uint32Array.from(values, (_, i) => i),\n      j = numbers.length - 1,\n      i = Math.floor(j * p);\n  quickselect(index, i, 0, j, (i, j) => ascendingDefined(numbers[i], numbers[j]));\n  i = greatest(index.subarray(0, i + 1), (i) => numbers[i]);\n  return i >= 0 ? i : -1;\n}\n","import {ascendingDefined, compareDefined} from \"./sort.js\";\n\n// Based on https://github.com/mourner/quickselect\n// ISC license, Copyright 2018 Vladimir Agafonkin.\nexport default function quickselect(array, k, left = 0, right = Infinity, compare) {\n  k = Math.floor(k);\n  left = Math.floor(Math.max(0, left));\n  right = Math.floor(Math.min(array.length - 1, right));\n\n  if (!(left <= k && k <= right)) return array;\n\n  compare = compare === undefined ? ascendingDefined : compareDefined(compare);\n\n  while (right > left) {\n    if (right - left > 600) {\n      const n = right - left + 1;\n      const m = k - left + 1;\n      const z = Math.log(n);\n      const s = 0.5 * Math.exp(2 * z / 3);\n      const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);\n      const newLeft = Math.max(left, Math.floor(k - m * s / n + sd));\n      const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));\n      quickselect(array, k, newLeft, newRight, compare);\n    }\n\n    const t = array[k];\n    let i = left;\n    let j = right;\n\n    swap(array, left, k);\n    if (compare(array[right], t) > 0) swap(array, left, right);\n\n    while (i < j) {\n      swap(array, i, j), ++i, --j;\n      while (compare(array[i], t) < 0) ++i;\n      while (compare(array[j], t) > 0) --j;\n    }\n\n    if (compare(array[left], t) === 0) swap(array, left, j);\n    else ++j, swap(array, j, right);\n\n    if (j <= k) left = j + 1;\n    if (k <= j) right = j - 1;\n  }\n\n  return array;\n}\n\nfunction swap(array, i, j) {\n  const t = array[i];\n  array[i] = array[j];\n  array[j] = t;\n}\n","import ascending from \"./ascending.js\";\nimport permute from \"./permute.js\";\n\nexport default function sort(values, ...F) {\n  if (typeof values[Symbol.iterator] !== \"function\") throw new TypeError(\"values is not iterable\");\n  values = Array.from(values);\n  let [f] = F;\n  if ((f && f.length !== 2) || F.length > 1) {\n    const index = Uint32Array.from(values, (d, i) => i);\n    if (F.length > 1) {\n      F = F.map(f => values.map(f));\n      index.sort((i, j) => {\n        for (const f of F) {\n          const c = ascendingDefined(f[i], f[j]);\n          if (c) return c;\n        }\n      });\n    } else {\n      f = values.map(f);\n      index.sort((i, j) => ascendingDefined(f[i], f[j]));\n    }\n    return permute(values, index);\n  }\n  return values.sort(compareDefined(f));\n}\n\nexport function compareDefined(compare = ascending) {\n  if (compare === ascending) return ascendingDefined;\n  if (typeof compare !== \"function\") throw new TypeError(\"compare is not a function\");\n  return (a, b) => {\n    const x = compare(a, b);\n    if (x || x === 0) return x;\n    return (compare(b, b) === 0) - (compare(a, a) === 0);\n  };\n}\n\nexport function ascendingDefined(a, b) {\n  return (a == null || !(a >= a)) - (b == null || !(b >= b)) || (a < b ? -1 : a > b ? 1 : 0);\n}\n","import define, {extend} from \"./define.js\";\nimport {Color, rgbConvert, Rgb, darker, brighter} from \"./color.js\";\nimport {degrees, radians} from \"./math.js\";\n\nvar A = -0.14861,\n    B = +1.78277,\n    C = -0.29227,\n    D = -0.90649,\n    E = +1.97294,\n    ED = E * D,\n    EB = E * B,\n    BC_DA = B * C - D * A;\n\nfunction cubehelixConvert(o) {\n  if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);\n  if (!(o instanceof Rgb)) o = rgbConvert(o);\n  var r = o.r / 255,\n      g = o.g / 255,\n      b = o.b / 255,\n      l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB),\n      bl = b - l,\n      k = (E * (g - l) - C * bl) / D,\n      s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1\n      h = s ? Math.atan2(k, bl) * degrees - 120 : NaN;\n  return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity);\n}\n\nexport default function cubehelix(h, s, l, opacity) {\n  return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity);\n}\n\nexport function Cubehelix(h, s, l, opacity) {\n  this.h = +h;\n  this.s = +s;\n  this.l = +l;\n  this.opacity = +opacity;\n}\n\ndefine(Cubehelix, cubehelix, extend(Color, {\n  brighter(k) {\n    k = k == null ? brighter : Math.pow(brighter, k);\n    return new Cubehelix(this.h, this.s, this.l * k, this.opacity);\n  },\n  darker(k) {\n    k = k == null ? darker : Math.pow(darker, k);\n    return new Cubehelix(this.h, this.s, this.l * k, this.opacity);\n  },\n  rgb() {\n    var h = isNaN(this.h) ? 0 : (this.h + 120) * radians,\n        l = +this.l,\n        a = isNaN(this.s) ? 0 : this.s * l * (1 - l),\n        cosh = Math.cos(h),\n        sinh = Math.sin(h);\n    return new Rgb(\n      255 * (l + a * (A * cosh + B * sinh)),\n      255 * (l + a * (C * cosh + D * sinh)),\n      255 * (l + a * (E * cosh)),\n      this.opacity\n    );\n  }\n}));\n","import define, {extend} from \"./define.js\";\nimport {Color, rgbConvert, Rgb} from \"./color.js\";\nimport {degrees, radians} from \"./math.js\";\n\n// https://observablehq.com/@mbostock/lab-and-rgb\nconst K = 18,\n    Xn = 0.96422,\n    Yn = 1,\n    Zn = 0.82521,\n    t0 = 4 / 29,\n    t1 = 6 / 29,\n    t2 = 3 * t1 * t1,\n    t3 = t1 * t1 * t1;\n\nfunction labConvert(o) {\n  if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);\n  if (o instanceof Hcl) return hcl2lab(o);\n  if (!(o instanceof Rgb)) o = rgbConvert(o);\n  var r = rgb2lrgb(o.r),\n      g = rgb2lrgb(o.g),\n      b = rgb2lrgb(o.b),\n      y = xyz2lab((0.2225045 * r + 0.7168786 * g + 0.0606169 * b) / Yn), x, z;\n  if (r === g && g === b) x = z = y; else {\n    x = xyz2lab((0.4360747 * r + 0.3850649 * g + 0.1430804 * b) / Xn);\n    z = xyz2lab((0.0139322 * r + 0.0971045 * g + 0.7141733 * b) / Zn);\n  }\n  return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);\n}\n\nexport function gray(l, opacity) {\n  return new Lab(l, 0, 0, opacity == null ? 1 : opacity);\n}\n\nexport default function lab(l, a, b, opacity) {\n  return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);\n}\n\nexport function Lab(l, a, b, opacity) {\n  this.l = +l;\n  this.a = +a;\n  this.b = +b;\n  this.opacity = +opacity;\n}\n\ndefine(Lab, lab, extend(Color, {\n  brighter(k) {\n    return new Lab(this.l + K * (k == null ? 1 : k), this.a, this.b, this.opacity);\n  },\n  darker(k) {\n    return new Lab(this.l - K * (k == null ? 1 : k), this.a, this.b, this.opacity);\n  },\n  rgb() {\n    var y = (this.l + 16) / 116,\n        x = isNaN(this.a) ? y : y + this.a / 500,\n        z = isNaN(this.b) ? y : y - this.b / 200;\n    x = Xn * lab2xyz(x);\n    y = Yn * lab2xyz(y);\n    z = Zn * lab2xyz(z);\n    return new Rgb(\n      lrgb2rgb( 3.1338561 * x - 1.6168667 * y - 0.4906146 * z),\n      lrgb2rgb(-0.9787684 * x + 1.9161415 * y + 0.0334540 * z),\n      lrgb2rgb( 0.0719453 * x - 0.2289914 * y + 1.4052427 * z),\n      this.opacity\n    );\n  }\n}));\n\nfunction xyz2lab(t) {\n  return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;\n}\n\nfunction lab2xyz(t) {\n  return t > t1 ? t * t * t : t2 * (t - t0);\n}\n\nfunction lrgb2rgb(x) {\n  return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);\n}\n\nfunction rgb2lrgb(x) {\n  return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);\n}\n\nfunction hclConvert(o) {\n  if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);\n  if (!(o instanceof Lab)) o = labConvert(o);\n  if (o.a === 0 && o.b === 0) return new Hcl(NaN, 0 < o.l && o.l < 100 ? 0 : NaN, o.l, o.opacity);\n  var h = Math.atan2(o.b, o.a) * degrees;\n  return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);\n}\n\nexport function lch(l, c, h, opacity) {\n  return arguments.length === 1 ? hclConvert(l) : new Hcl(h, c, l, opacity == null ? 1 : opacity);\n}\n\nexport function hcl(h, c, l, opacity) {\n  return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);\n}\n\nexport function Hcl(h, c, l, opacity) {\n  this.h = +h;\n  this.c = +c;\n  this.l = +l;\n  this.opacity = +opacity;\n}\n\nfunction hcl2lab(o) {\n  if (isNaN(o.h)) return new Lab(o.l, 0, 0, o.opacity);\n  var h = o.h * radians;\n  return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);\n}\n\ndefine(Hcl, hcl, extend(Color, {\n  brighter(k) {\n    return new Hcl(this.h, this.c, this.l + K * (k == null ? 1 : k), this.opacity);\n  },\n  darker(k) {\n    return new Hcl(this.h, this.c, this.l - K * (k == null ? 1 : k), this.opacity);\n  },\n  rgb() {\n    return hcl2lab(this).rgb();\n  }\n}));\n","export const radians = Math.PI / 180;\nexport const degrees = 180 / Math.PI;\n","function defaultSeparation(a, b) {\n  return a.parent === b.parent ? 1 : 2;\n}\n\nfunction meanX(children) {\n  return children.reduce(meanXReduce, 0) / children.length;\n}\n\nfunction meanXReduce(x, c) {\n  return x + c.x;\n}\n\nfunction maxY(children) {\n  return 1 + children.reduce(maxYReduce, 0);\n}\n\nfunction maxYReduce(y, c) {\n  return Math.max(y, c.y);\n}\n\nfunction leafLeft(node) {\n  var children;\n  while (children = node.children) node = children[0];\n  return node;\n}\n\nfunction leafRight(node) {\n  var children;\n  while (children = node.children) node = children[children.length - 1];\n  return node;\n}\n\nexport default function() {\n  var separation = defaultSeparation,\n      dx = 1,\n      dy = 1,\n      nodeSize = false;\n\n  function cluster(root) {\n    var previousNode,\n        x = 0;\n\n    // First walk, computing the initial x & y values.\n    root.eachAfter(function(node) {\n      var children = node.children;\n      if (children) {\n        node.x = meanX(children);\n        node.y = maxY(children);\n      } else {\n        node.x = previousNode ? x += separation(node, previousNode) : 0;\n        node.y = 0;\n        previousNode = node;\n      }\n    });\n\n    var left = leafLeft(root),\n        right = leafRight(root),\n        x0 = left.x - separation(left, right) / 2,\n        x1 = right.x + separation(right, left) / 2;\n\n    // Second walk, normalizing x & y to the desired size.\n    return root.eachAfter(nodeSize ? function(node) {\n      node.x = (node.x - root.x) * dx;\n      node.y = (root.y - node.y) * dy;\n    } : function(node) {\n      node.x = (node.x - x0) / (x1 - x0) * dx;\n      node.y = (1 - (root.y ? node.y / root.y : 1)) * dy;\n    });\n  }\n\n  cluster.separation = function(x) {\n    return arguments.length ? (separation = x, cluster) : separation;\n  };\n\n  cluster.size = function(x) {\n    return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? null : [dx, dy]);\n  };\n\n  cluster.nodeSize = function(x) {\n    return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? [dx, dy] : null);\n  };\n\n  return cluster;\n}\n","import {optional} from \"./accessors.js\";\nimport {Node, computeHeight} from \"./hierarchy/index.js\";\n\nvar preroot = {depth: -1},\n    ambiguous = {},\n    imputed = {};\n\nfunction defaultId(d) {\n  return d.id;\n}\n\nfunction defaultParentId(d) {\n  return d.parentId;\n}\n\nexport default function() {\n  var id = defaultId,\n      parentId = defaultParentId,\n      path;\n\n  function stratify(data) {\n    var nodes = Array.from(data),\n        currentId = id,\n        currentParentId = parentId,\n        n,\n        d,\n        i,\n        root,\n        parent,\n        node,\n        nodeId,\n        nodeKey,\n        nodeByKey = new Map;\n\n    if (path != null) {\n      const I = nodes.map((d, i) => normalize(path(d, i, data)));\n      const P = I.map(parentof);\n      const S = new Set(I).add(\"\");\n      for (const i of P) {\n        if (!S.has(i)) {\n          S.add(i);\n          I.push(i);\n          P.push(parentof(i));\n          nodes.push(imputed);\n        }\n      }\n      currentId = (_, i) => I[i];\n      currentParentId = (_, i) => P[i];\n    }\n\n    for (i = 0, n = nodes.length; i < n; ++i) {\n      d = nodes[i], node = nodes[i] = new Node(d);\n      if ((nodeId = currentId(d, i, data)) != null && (nodeId += \"\")) {\n        nodeKey = node.id = nodeId;\n        nodeByKey.set(nodeKey, nodeByKey.has(nodeKey) ? ambiguous : node);\n      }\n      if ((nodeId = currentParentId(d, i, data)) != null && (nodeId += \"\")) {\n        node.parent = nodeId;\n      }\n    }\n\n    for (i = 0; i < n; ++i) {\n      node = nodes[i];\n      if (nodeId = node.parent) {\n        parent = nodeByKey.get(nodeId);\n        if (!parent) throw new Error(\"missing: \" + nodeId);\n        if (parent === ambiguous) throw new Error(\"ambiguous: \" + nodeId);\n        if (parent.children) parent.children.push(node);\n        else parent.children = [node];\n        node.parent = parent;\n      } else {\n        if (root) throw new Error(\"multiple roots\");\n        root = node;\n      }\n    }\n\n    if (!root) throw new Error(\"no root\");\n\n    // When imputing internal nodes, only introduce roots if needed.\n    // Then replace the imputed marker data with null.\n    if (path != null) {\n      while (root.data === imputed && root.children.length === 1) {\n        root = root.children[0], --n;\n      }\n      for (let i = nodes.length - 1; i >= 0; --i) {\n        node = nodes[i];\n        if (node.data !== imputed) break;\n        node.data = null;\n      }\n    }\n\n    root.parent = preroot;\n    root.eachBefore(function(node) { node.depth = node.parent.depth + 1; --n; }).eachBefore(computeHeight);\n    root.parent = null;\n    if (n > 0) throw new Error(\"cycle\");\n\n    return root;\n  }\n\n  stratify.id = function(x) {\n    return arguments.length ? (id = optional(x), stratify) : id;\n  };\n\n  stratify.parentId = function(x) {\n    return arguments.length ? (parentId = optional(x), stratify) : parentId;\n  };\n\n  stratify.path = function(x) {\n    return arguments.length ? (path = optional(x), stratify) : path;\n  };\n\n  return stratify;\n}\n\n// To normalize a path, we coerce to a string, strip the trailing slash if any\n// (as long as the trailing slash is not immediately preceded by another slash),\n// and add leading slash if missing.\nfunction normalize(path) {\n  path = `${path}`;\n  let i = path.length;\n  if (slash(path, i - 1) && !slash(path, i - 2)) path = path.slice(0, -1);\n  return path[0] === \"/\" ? path : `/${path}`;\n}\n\n// Walk backwards to find the first slash that is not the leading slash, e.g.:\n// \"/foo/bar\" ⇥ \"/foo\", \"/foo\" ⇥ \"/\", \"/\" ↦ \"\". (The root is special-cased\n// because the id of the root must be a truthy value.)\nfunction parentof(path) {\n  let i = path.length;\n  if (i < 2) return \"\";\n  while (--i > 1) if (slash(path, i)) break;\n  return path.slice(0, i);\n}\n\n// Slashes can be escaped; to determine whether a slash is a path delimiter, we\n// count the number of preceding backslashes escaping the forward slash: an odd\n// number indicates an escaped forward slash.\nfunction slash(path, i) {\n  if (path[i] === \"/\") {\n    let k = 0;\n    while (i > 0 && path[--i] === \"\\\\\") ++k;\n    if ((k & 1) === 0) return true;\n  }\n  return false;\n}\n","import {Node} from \"./hierarchy/index.js\";\n\nfunction defaultSeparation(a, b) {\n  return a.parent === b.parent ? 1 : 2;\n}\n\n// function radialSeparation(a, b) {\n//   return (a.parent === b.parent ? 1 : 2) / a.depth;\n// }\n\n// This function is used to traverse the left contour of a subtree (or\n// subforest). It returns the successor of v on this contour. This successor is\n// either given by the leftmost child of v or by the thread of v. The function\n// returns null if and only if v is on the highest level of its subtree.\nfunction nextLeft(v) {\n  var children = v.children;\n  return children ? children[0] : v.t;\n}\n\n// This function works analogously to nextLeft.\nfunction nextRight(v) {\n  var children = v.children;\n  return children ? children[children.length - 1] : v.t;\n}\n\n// Shifts the current subtree rooted at w+. This is done by increasing\n// prelim(w+) and mod(w+) by shift.\nfunction moveSubtree(wm, wp, shift) {\n  var change = shift / (wp.i - wm.i);\n  wp.c -= change;\n  wp.s += shift;\n  wm.c += change;\n  wp.z += shift;\n  wp.m += shift;\n}\n\n// All other shifts, applied to the smaller subtrees between w- and w+, are\n// performed by this function. To prepare the shifts, we have to adjust\n// change(w+), shift(w+), and change(w-).\nfunction executeShifts(v) {\n  var shift = 0,\n      change = 0,\n      children = v.children,\n      i = children.length,\n      w;\n  while (--i >= 0) {\n    w = children[i];\n    w.z += shift;\n    w.m += shift;\n    shift += w.s + (change += w.c);\n  }\n}\n\n// If vi-’s ancestor is a sibling of v, returns vi-’s ancestor. Otherwise,\n// returns the specified (default) ancestor.\nfunction nextAncestor(vim, v, ancestor) {\n  return vim.a.parent === v.parent ? vim.a : ancestor;\n}\n\nfunction TreeNode(node, i) {\n  this._ = node;\n  this.parent = null;\n  this.children = null;\n  this.A = null; // default ancestor\n  this.a = this; // ancestor\n  this.z = 0; // prelim\n  this.m = 0; // mod\n  this.c = 0; // change\n  this.s = 0; // shift\n  this.t = null; // thread\n  this.i = i; // number\n}\n\nTreeNode.prototype = Object.create(Node.prototype);\n\nfunction treeRoot(root) {\n  var tree = new TreeNode(root, 0),\n      node,\n      nodes = [tree],\n      child,\n      children,\n      i,\n      n;\n\n  while (node = nodes.pop()) {\n    if (children = node._.children) {\n      node.children = new Array(n = children.length);\n      for (i = n - 1; i >= 0; --i) {\n        nodes.push(child = node.children[i] = new TreeNode(children[i], i));\n        child.parent = node;\n      }\n    }\n  }\n\n  (tree.parent = new TreeNode(null, 0)).children = [tree];\n  return tree;\n}\n\n// Node-link tree diagram using the Reingold-Tilford \"tidy\" algorithm\nexport default function() {\n  var separation = defaultSeparation,\n      dx = 1,\n      dy = 1,\n      nodeSize = null;\n\n  function tree(root) {\n    var t = treeRoot(root);\n\n    // Compute the layout using Buchheim et al.’s algorithm.\n    t.eachAfter(firstWalk), t.parent.m = -t.z;\n    t.eachBefore(secondWalk);\n\n    // If a fixed node size is specified, scale x and y.\n    if (nodeSize) root.eachBefore(sizeNode);\n\n    // If a fixed tree size is specified, scale x and y based on the extent.\n    // Compute the left-most, right-most, and depth-most nodes for extents.\n    else {\n      var left = root,\n          right = root,\n          bottom = root;\n      root.eachBefore(function(node) {\n        if (node.x < left.x) left = node;\n        if (node.x > right.x) right = node;\n        if (node.depth > bottom.depth) bottom = node;\n      });\n      var s = left === right ? 1 : separation(left, right) / 2,\n          tx = s - left.x,\n          kx = dx / (right.x + s + tx),\n          ky = dy / (bottom.depth || 1);\n      root.eachBefore(function(node) {\n        node.x = (node.x + tx) * kx;\n        node.y = node.depth * ky;\n      });\n    }\n\n    return root;\n  }\n\n  // Computes a preliminary x-coordinate for v. Before that, FIRST WALK is\n  // applied recursively to the children of v, as well as the function\n  // APPORTION. After spacing out the children by calling EXECUTE SHIFTS, the\n  // node v is placed to the midpoint of its outermost children.\n  function firstWalk(v) {\n    var children = v.children,\n        siblings = v.parent.children,\n        w = v.i ? siblings[v.i - 1] : null;\n    if (children) {\n      executeShifts(v);\n      var midpoint = (children[0].z + children[children.length - 1].z) / 2;\n      if (w) {\n        v.z = w.z + separation(v._, w._);\n        v.m = v.z - midpoint;\n      } else {\n        v.z = midpoint;\n      }\n    } else if (w) {\n      v.z = w.z + separation(v._, w._);\n    }\n    v.parent.A = apportion(v, w, v.parent.A || siblings[0]);\n  }\n\n  // Computes all real x-coordinates by summing up the modifiers recursively.\n  function secondWalk(v) {\n    v._.x = v.z + v.parent.m;\n    v.m += v.parent.m;\n  }\n\n  // The core of the algorithm. Here, a new subtree is combined with the\n  // previous subtrees. Threads are used to traverse the inside and outside\n  // contours of the left and right subtree up to the highest common level. The\n  // vertices used for the traversals are vi+, vi-, vo-, and vo+, where the\n  // superscript o means outside and i means inside, the subscript - means left\n  // subtree and + means right subtree. For summing up the modifiers along the\n  // contour, we use respective variables si+, si-, so-, and so+. Whenever two\n  // nodes of the inside contours conflict, we compute the left one of the\n  // greatest uncommon ancestors using the function ANCESTOR and call MOVE\n  // SUBTREE to shift the subtree and prepare the shifts of smaller subtrees.\n  // Finally, we add a new thread (if necessary).\n  function apportion(v, w, ancestor) {\n    if (w) {\n      var vip = v,\n          vop = v,\n          vim = w,\n          vom = vip.parent.children[0],\n          sip = vip.m,\n          sop = vop.m,\n          sim = vim.m,\n          som = vom.m,\n          shift;\n      while (vim = nextRight(vim), vip = nextLeft(vip), vim && vip) {\n        vom = nextLeft(vom);\n        vop = nextRight(vop);\n        vop.a = v;\n        shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);\n        if (shift > 0) {\n          moveSubtree(nextAncestor(vim, v, ancestor), v, shift);\n          sip += shift;\n          sop += shift;\n        }\n        sim += vim.m;\n        sip += vip.m;\n        som += vom.m;\n        sop += vop.m;\n      }\n      if (vim && !nextRight(vop)) {\n        vop.t = vim;\n        vop.m += sim - sop;\n      }\n      if (vip && !nextLeft(vom)) {\n        vom.t = vip;\n        vom.m += sip - som;\n        ancestor = v;\n      }\n    }\n    return ancestor;\n  }\n\n  function sizeNode(node) {\n    node.x *= dx;\n    node.y = node.depth * dy;\n  }\n\n  tree.separation = function(x) {\n    return arguments.length ? (separation = x, tree) : separation;\n  };\n\n  tree.size = function(x) {\n    return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], tree) : (nodeSize ? null : [dx, dy]);\n  };\n\n  tree.nodeSize = function(x) {\n    return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], tree) : (nodeSize ? [dx, dy] : null);\n  };\n\n  return tree;\n}\n","import {cubehelix as colorCubehelix} from \"d3-color\";\nimport color, {hue} from \"./color.js\";\n\nfunction cubehelix(hue) {\n  return (function cubehelixGamma(y) {\n    y = +y;\n\n    function cubehelix(start, end) {\n      var h = hue((start = colorCubehelix(start)).h, (end = colorCubehelix(end)).h),\n          s = color(start.s, end.s),\n          l = color(start.l, end.l),\n          opacity = color(start.opacity, end.opacity);\n      return function(t) {\n        start.h = h(t);\n        start.s = s(t);\n        start.l = l(Math.pow(t, y));\n        start.opacity = opacity(t);\n        return start + \"\";\n      };\n    }\n\n    cubehelix.gamma = cubehelixGamma;\n\n    return cubehelix;\n  })(1);\n}\n\nexport default cubehelix(hue);\nexport var cubehelixLong = cubehelix(color);\n","export default function(range) {\n  var n = range.length;\n  return function(t) {\n    return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];\n  };\n}\n","import {hue} from \"./color.js\";\n\nexport default function(a, b) {\n  var i = hue(+a, +b);\n  return function(t) {\n    var x = i(t);\n    return x - 360 * Math.floor(x / 360);\n  };\n}\n","import {hsl as colorHsl} from \"d3-color\";\nimport color, {hue} from \"./color.js\";\n\nfunction hsl(hue) {\n  return function(start, end) {\n    var h = hue((start = colorHsl(start)).h, (end = colorHsl(end)).h),\n        s = color(start.s, end.s),\n        l = color(start.l, end.l),\n        opacity = color(start.opacity, end.opacity);\n    return function(t) {\n      start.h = h(t);\n      start.s = s(t);\n      start.l = l(t);\n      start.opacity = opacity(t);\n      return start + \"\";\n    };\n  }\n}\n\nexport default hsl(hue);\nexport var hslLong = hsl(color);\n","import {lab as colorLab} from \"d3-color\";\nimport color from \"./color.js\";\n\nexport default function lab(start, end) {\n  var l = color((start = colorLab(start)).l, (end = colorLab(end)).l),\n      a = color(start.a, end.a),\n      b = color(start.b, end.b),\n      opacity = color(start.opacity, end.opacity);\n  return function(t) {\n    start.l = l(t);\n    start.a = a(t);\n    start.b = b(t);\n    start.opacity = opacity(t);\n    return start + \"\";\n  };\n}\n","import {hcl as colorHcl} from \"d3-color\";\nimport color, {hue} from \"./color.js\";\n\nfunction hcl(hue) {\n  return function(start, end) {\n    var h = hue((start = colorHcl(start)).h, (end = colorHcl(end)).h),\n        c = color(start.c, end.c),\n        l = color(start.l, end.l),\n        opacity = color(start.opacity, end.opacity);\n    return function(t) {\n      start.h = h(t);\n      start.c = c(t);\n      start.l = l(t);\n      start.opacity = opacity(t);\n      return start + \"\";\n    };\n  }\n}\n\nexport default hcl(hue);\nexport var hclLong = hcl(color);\n","export default function(interpolator, n) {\n  var samples = new Array(n);\n  for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1));\n  return samples;\n}\n","import {default as value} from \"./value.js\";\n\nexport default function piecewise(interpolate, values) {\n  if (values === undefined) values = interpolate, interpolate = value;\n  var i = 0, n = values.length - 1, v = values[0], I = new Array(n < 0 ? 0 : n);\n  while (i < n) I[i] = interpolate(v, v = values[++i]);\n  return function(t) {\n    var i = Math.max(0, Math.min(n - 1, Math.floor(t *= n)));\n    return I[i](t - i);\n  };\n}\n","import {linearish} from \"./linear.js\";\nimport number from \"./number.js\";\n\nexport default function identity(domain) {\n  var unknown;\n\n  function scale(x) {\n    return x == null || isNaN(x = +x) ? unknown : x;\n  }\n\n  scale.invert = scale;\n\n  scale.domain = scale.range = function(_) {\n    return arguments.length ? (domain = Array.from(_, number), scale) : domain.slice();\n  };\n\n  scale.unknown = function(_) {\n    return arguments.length ? (unknown = _, scale) : unknown;\n  };\n\n  scale.copy = function() {\n    return identity(domain).unknown(unknown);\n  };\n\n  domain = arguments.length ? Array.from(domain, number) : [0, 1];\n\n  return linearish(scale);\n}\n","import {linearish} from \"./linear.js\";\nimport {copy, transformer} from \"./continuous.js\";\nimport {initRange} from \"./init.js\";\n\nfunction transformSymlog(c) {\n  return function(x) {\n    return Math.sign(x) * Math.log1p(Math.abs(x / c));\n  };\n}\n\nfunction transformSymexp(c) {\n  return function(x) {\n    return Math.sign(x) * Math.expm1(Math.abs(x)) * c;\n  };\n}\n\nexport function symlogish(transform) {\n  var c = 1, scale = transform(transformSymlog(c), transformSymexp(c));\n\n  scale.constant = function(_) {\n    return arguments.length ? transform(transformSymlog(c = +_), transformSymexp(c)) : c;\n  };\n\n  return linearish(scale);\n}\n\nexport default function symlog() {\n  var scale = symlogish(transformer());\n\n  scale.copy = function() {\n    return copy(scale, symlog()).constant(scale.constant());\n  };\n\n  return initRange.apply(scale, arguments);\n}\n","import continuous from \"./continuous.js\";\nimport {initRange} from \"./init.js\";\nimport {linearish} from \"./linear.js\";\nimport number from \"./number.js\";\n\nfunction square(x) {\n  return Math.sign(x) * x * x;\n}\n\nfunction unsquare(x) {\n  return Math.sign(x) * Math.sqrt(Math.abs(x));\n}\n\nexport default function radial() {\n  var squared = continuous(),\n      range = [0, 1],\n      round = false,\n      unknown;\n\n  function scale(x) {\n    var y = unsquare(squared(x));\n    return isNaN(y) ? unknown : round ? Math.round(y) : y;\n  }\n\n  scale.invert = function(y) {\n    return squared.invert(square(y));\n  };\n\n  scale.domain = function(_) {\n    return arguments.length ? (squared.domain(_), scale) : squared.domain();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (squared.range((range = Array.from(_, number)).map(square)), scale) : range.slice();\n  };\n\n  scale.rangeRound = function(_) {\n    return scale.range(_).round(true);\n  };\n\n  scale.round = function(_) {\n    return arguments.length ? (round = !!_, scale) : round;\n  };\n\n  scale.clamp = function(_) {\n    return arguments.length ? (squared.clamp(_), scale) : squared.clamp();\n  };\n\n  scale.unknown = function(_) {\n    return arguments.length ? (unknown = _, scale) : unknown;\n  };\n\n  scale.copy = function() {\n    return radial(squared.domain(), range)\n        .round(round)\n        .clamp(squared.clamp())\n        .unknown(unknown);\n  };\n\n  initRange.apply(scale, arguments);\n\n  return linearish(scale);\n}\n","import {ascending, bisect, quantileSorted as threshold} from \"d3-array\";\nimport {initRange} from \"./init.js\";\n\nexport default function quantile() {\n  var domain = [],\n      range = [],\n      thresholds = [],\n      unknown;\n\n  function rescale() {\n    var i = 0, n = Math.max(1, range.length);\n    thresholds = new Array(n - 1);\n    while (++i < n) thresholds[i - 1] = threshold(domain, i / n);\n    return scale;\n  }\n\n  function scale(x) {\n    return x == null || isNaN(x = +x) ? unknown : range[bisect(thresholds, x)];\n  }\n\n  scale.invertExtent = function(y) {\n    var i = range.indexOf(y);\n    return i < 0 ? [NaN, NaN] : [\n      i > 0 ? thresholds[i - 1] : domain[0],\n      i < thresholds.length ? thresholds[i] : domain[domain.length - 1]\n    ];\n  };\n\n  scale.domain = function(_) {\n    if (!arguments.length) return domain.slice();\n    domain = [];\n    for (let d of _) if (d != null && !isNaN(d = +d)) domain.push(d);\n    domain.sort(ascending);\n    return rescale();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range = Array.from(_), rescale()) : range.slice();\n  };\n\n  scale.unknown = function(_) {\n    return arguments.length ? (unknown = _, scale) : unknown;\n  };\n\n  scale.quantiles = function() {\n    return thresholds.slice();\n  };\n\n  scale.copy = function() {\n    return quantile()\n        .domain(domain)\n        .range(range)\n        .unknown(unknown);\n  };\n\n  return initRange.apply(scale, arguments);\n}\n","import {bisect} from \"d3-array\";\nimport {linearish} from \"./linear.js\";\nimport {initRange} from \"./init.js\";\n\nexport default function quantize() {\n  var x0 = 0,\n      x1 = 1,\n      n = 1,\n      domain = [0.5],\n      range = [0, 1],\n      unknown;\n\n  function scale(x) {\n    return x != null && x <= x ? range[bisect(domain, x, 0, n)] : unknown;\n  }\n\n  function rescale() {\n    var i = -1;\n    domain = new Array(n);\n    while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1);\n    return scale;\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? ([x0, x1] = _, x0 = +x0, x1 = +x1, rescale()) : [x0, x1];\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (n = (range = Array.from(_)).length - 1, rescale()) : range.slice();\n  };\n\n  scale.invertExtent = function(y) {\n    var i = range.indexOf(y);\n    return i < 0 ? [NaN, NaN]\n        : i < 1 ? [x0, domain[0]]\n        : i >= n ? [domain[n - 1], x1]\n        : [domain[i - 1], domain[i]];\n  };\n\n  scale.unknown = function(_) {\n    return arguments.length ? (unknown = _, scale) : scale;\n  };\n\n  scale.thresholds = function() {\n    return domain.slice();\n  };\n\n  scale.copy = function() {\n    return quantize()\n        .domain([x0, x1])\n        .range(range)\n        .unknown(unknown);\n  };\n\n  return initRange.apply(linearish(scale), arguments);\n}\n","import {bisect} from \"d3-array\";\nimport {initRange} from \"./init.js\";\n\nexport default function threshold() {\n  var domain = [0.5],\n      range = [0, 1],\n      unknown,\n      n = 1;\n\n  function scale(x) {\n    return x != null && x <= x ? range[bisect(domain, x, 0, n)] : unknown;\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? (domain = Array.from(_), n = Math.min(domain.length, range.length - 1), scale) : domain.slice();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range = Array.from(_), n = Math.min(domain.length, range.length - 1), scale) : range.slice();\n  };\n\n  scale.invertExtent = function(y) {\n    var i = range.indexOf(y);\n    return [domain[i - 1], domain[i]];\n  };\n\n  scale.unknown = function(_) {\n    return arguments.length ? (unknown = _, scale) : unknown;\n  };\n\n  scale.copy = function() {\n    return threshold()\n        .domain(domain)\n        .range(range)\n        .unknown(unknown);\n  };\n\n  return initRange.apply(scale, arguments);\n}\n","import {interpolate, interpolateRound} from \"d3-interpolate\";\nimport {identity} from \"./continuous.js\";\nimport {initInterpolator} from \"./init.js\";\nimport {linearish} from \"./linear.js\";\nimport {loggish} from \"./log.js\";\nimport {symlogish} from \"./symlog.js\";\nimport {powish} from \"./pow.js\";\n\nfunction transformer() {\n  var x0 = 0,\n      x1 = 1,\n      t0,\n      t1,\n      k10,\n      transform,\n      interpolator = identity,\n      clamp = false,\n      unknown;\n\n  function scale(x) {\n    return x == null || isNaN(x = +x) ? unknown : interpolator(k10 === 0 ? 0.5 : (x = (transform(x) - t0) * k10, clamp ? Math.max(0, Math.min(1, x)) : x));\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? ([x0, x1] = _, t0 = transform(x0 = +x0), t1 = transform(x1 = +x1), k10 = t0 === t1 ? 0 : 1 / (t1 - t0), scale) : [x0, x1];\n  };\n\n  scale.clamp = function(_) {\n    return arguments.length ? (clamp = !!_, scale) : clamp;\n  };\n\n  scale.interpolator = function(_) {\n    return arguments.length ? (interpolator = _, scale) : interpolator;\n  };\n\n  function range(interpolate) {\n    return function(_) {\n      var r0, r1;\n      return arguments.length ? ([r0, r1] = _, interpolator = interpolate(r0, r1), scale) : [interpolator(0), interpolator(1)];\n    };\n  }\n\n  scale.range = range(interpolate);\n\n  scale.rangeRound = range(interpolateRound);\n\n  scale.unknown = function(_) {\n    return arguments.length ? (unknown = _, scale) : unknown;\n  };\n\n  return function(t) {\n    transform = t, t0 = t(x0), t1 = t(x1), k10 = t0 === t1 ? 0 : 1 / (t1 - t0);\n    return scale;\n  };\n}\n\nexport function copy(source, target) {\n  return target\n      .domain(source.domain())\n      .interpolator(source.interpolator())\n      .clamp(source.clamp())\n      .unknown(source.unknown());\n}\n\nexport default function sequential() {\n  var scale = linearish(transformer()(identity));\n\n  scale.copy = function() {\n    return copy(scale, sequential());\n  };\n\n  return initInterpolator.apply(scale, arguments);\n}\n\nexport function sequentialLog() {\n  var scale = loggish(transformer()).domain([1, 10]);\n\n  scale.copy = function() {\n    return copy(scale, sequentialLog()).base(scale.base());\n  };\n\n  return initInterpolator.apply(scale, arguments);\n}\n\nexport function sequentialSymlog() {\n  var scale = symlogish(transformer());\n\n  scale.copy = function() {\n    return copy(scale, sequentialSymlog()).constant(scale.constant());\n  };\n\n  return initInterpolator.apply(scale, arguments);\n}\n\nexport function sequentialPow() {\n  var scale = powish(transformer());\n\n  scale.copy = function() {\n    return copy(scale, sequentialPow()).exponent(scale.exponent());\n  };\n\n  return initInterpolator.apply(scale, arguments);\n}\n\nexport function sequentialSqrt() {\n  return sequentialPow.apply(null, arguments).exponent(0.5);\n}\n","import {ascending, bisect, quantile} from \"d3-array\";\nimport {identity} from \"./continuous.js\";\nimport {initInterpolator} from \"./init.js\";\n\nexport default function sequentialQuantile() {\n  var domain = [],\n      interpolator = identity;\n\n  function scale(x) {\n    if (x != null && !isNaN(x = +x)) return interpolator((bisect(domain, x, 1) - 1) / (domain.length - 1));\n  }\n\n  scale.domain = function(_) {\n    if (!arguments.length) return domain.slice();\n    domain = [];\n    for (let d of _) if (d != null && !isNaN(d = +d)) domain.push(d);\n    domain.sort(ascending);\n    return scale;\n  };\n\n  scale.interpolator = function(_) {\n    return arguments.length ? (interpolator = _, scale) : interpolator;\n  };\n\n  scale.range = function() {\n    return domain.map((d, i) => interpolator(i / (domain.length - 1)));\n  };\n\n  scale.quantiles = function(n) {\n    return Array.from({length: n + 1}, (_, i) => quantile(domain, i / n));\n  };\n\n  scale.copy = function() {\n    return sequentialQuantile(interpolator).domain(domain);\n  };\n\n  return initInterpolator.apply(scale, arguments);\n}\n","import {interpolate, interpolateRound, piecewise} from \"d3-interpolate\";\nimport {identity} from \"./continuous.js\";\nimport {initInterpolator} from \"./init.js\";\nimport {linearish} from \"./linear.js\";\nimport {loggish} from \"./log.js\";\nimport {copy} from \"./sequential.js\";\nimport {symlogish} from \"./symlog.js\";\nimport {powish} from \"./pow.js\";\n\nfunction transformer() {\n  var x0 = 0,\n      x1 = 0.5,\n      x2 = 1,\n      s = 1,\n      t0,\n      t1,\n      t2,\n      k10,\n      k21,\n      interpolator = identity,\n      transform,\n      clamp = false,\n      unknown;\n\n  function scale(x) {\n    return isNaN(x = +x) ? unknown : (x = 0.5 + ((x = +transform(x)) - t1) * (s * x < s * t1 ? k10 : k21), interpolator(clamp ? Math.max(0, Math.min(1, x)) : x));\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? ([x0, x1, x2] = _, t0 = transform(x0 = +x0), t1 = transform(x1 = +x1), t2 = transform(x2 = +x2), k10 = t0 === t1 ? 0 : 0.5 / (t1 - t0), k21 = t1 === t2 ? 0 : 0.5 / (t2 - t1), s = t1 < t0 ? -1 : 1, scale) : [x0, x1, x2];\n  };\n\n  scale.clamp = function(_) {\n    return arguments.length ? (clamp = !!_, scale) : clamp;\n  };\n\n  scale.interpolator = function(_) {\n    return arguments.length ? (interpolator = _, scale) : interpolator;\n  };\n\n  function range(interpolate) {\n    return function(_) {\n      var r0, r1, r2;\n      return arguments.length ? ([r0, r1, r2] = _, interpolator = piecewise(interpolate, [r0, r1, r2]), scale) : [interpolator(0), interpolator(0.5), interpolator(1)];\n    };\n  }\n\n  scale.range = range(interpolate);\n\n  scale.rangeRound = range(interpolateRound);\n\n  scale.unknown = function(_) {\n    return arguments.length ? (unknown = _, scale) : unknown;\n  };\n\n  return function(t) {\n    transform = t, t0 = t(x0), t1 = t(x1), t2 = t(x2), k10 = t0 === t1 ? 0 : 0.5 / (t1 - t0), k21 = t1 === t2 ? 0 : 0.5 / (t2 - t1), s = t1 < t0 ? -1 : 1;\n    return scale;\n  };\n}\n\nexport default function diverging() {\n  var scale = linearish(transformer()(identity));\n\n  scale.copy = function() {\n    return copy(scale, diverging());\n  };\n\n  return initInterpolator.apply(scale, arguments);\n}\n\nexport function divergingLog() {\n  var scale = loggish(transformer()).domain([0.1, 1, 10]);\n\n  scale.copy = function() {\n    return copy(scale, divergingLog()).base(scale.base());\n  };\n\n  return initInterpolator.apply(scale, arguments);\n}\n\nexport function divergingSymlog() {\n  var scale = symlogish(transformer());\n\n  scale.copy = function() {\n    return copy(scale, divergingSymlog()).constant(scale.constant());\n  };\n\n  return initInterpolator.apply(scale, arguments);\n}\n\nexport function divergingPow() {\n  var scale = powish(transformer());\n\n  scale.copy = function() {\n    return copy(scale, divergingPow()).exponent(scale.exponent());\n  };\n\n  return initInterpolator.apply(scale, arguments);\n}\n\nexport function divergingSqrt() {\n  return divergingPow.apply(null, arguments).exponent(0.5);\n}\n","import creator from \"./creator.js\";\nimport select from \"./select.js\";\n\nexport default function(name) {\n  return select(creator(name).call(document.documentElement));\n}\n","var nextId = 0;\n\nexport default function local() {\n  return new Local;\n}\n\nfunction Local() {\n  this._ = \"@\" + (++nextId).toString(36);\n}\n\nLocal.prototype = local.prototype = {\n  constructor: Local,\n  get: function(node) {\n    var id = this._;\n    while (!(id in node)) if (!(node = node.parentNode)) return;\n    return node[id];\n  },\n  set: function(node, value) {\n    return node[this._] = value;\n  },\n  remove: function(node) {\n    return this._ in node && delete node[this._];\n  },\n  toString: function() {\n    return this._;\n  }\n};\n","import pointer from \"./pointer.js\";\nimport sourceEvent from \"./sourceEvent.js\";\n\nexport default function(events, node) {\n  if (events.target) { // i.e., instanceof Event, not TouchList or iterable\n    events = sourceEvent(events);\n    if (node === undefined) node = events.currentTarget;\n    events = events.touches || [events];\n  }\n  return Array.from(events, event => pointer(event, node));\n}\n","import array from \"./array.js\";\nimport {Selection, root} from \"./selection/index.js\";\n\nexport default function(selector) {\n  return typeof selector === \"string\"\n      ? new Selection([document.querySelectorAll(selector)], [document.documentElement])\n      : new Selection([array(selector)], root);\n}\n","export const epsilon = 1.1102230246251565e-16;\nexport const splitter = 134217729;\nexport const resulterrbound = (3 + 8 * epsilon) * epsilon;\n\n// fast_expansion_sum_zeroelim routine from oritinal code\nexport function sum(elen, e, flen, f, h) {\n    let Q, Qnew, hh, bvirt;\n    let enow = e[0];\n    let fnow = f[0];\n    let eindex = 0;\n    let findex = 0;\n    if ((fnow > enow) === (fnow > -enow)) {\n        Q = enow;\n        enow = e[++eindex];\n    } else {\n        Q = fnow;\n        fnow = f[++findex];\n    }\n    let hindex = 0;\n    if (eindex < elen && findex < flen) {\n        if ((fnow > enow) === (fnow > -enow)) {\n            Qnew = enow + Q;\n            hh = Q - (Qnew - enow);\n            enow = e[++eindex];\n        } else {\n            Qnew = fnow + Q;\n            hh = Q - (Qnew - fnow);\n            fnow = f[++findex];\n        }\n        Q = Qnew;\n        if (hh !== 0) {\n            h[hindex++] = hh;\n        }\n        while (eindex < elen && findex < flen) {\n            if ((fnow > enow) === (fnow > -enow)) {\n                Qnew = Q + enow;\n                bvirt = Qnew - Q;\n                hh = Q - (Qnew - bvirt) + (enow - bvirt);\n                enow = e[++eindex];\n            } else {\n                Qnew = Q + fnow;\n                bvirt = Qnew - Q;\n                hh = Q - (Qnew - bvirt) + (fnow - bvirt);\n                fnow = f[++findex];\n            }\n            Q = Qnew;\n            if (hh !== 0) {\n                h[hindex++] = hh;\n            }\n        }\n    }\n    while (eindex < elen) {\n        Qnew = Q + enow;\n        bvirt = Qnew - Q;\n        hh = Q - (Qnew - bvirt) + (enow - bvirt);\n        enow = e[++eindex];\n        Q = Qnew;\n        if (hh !== 0) {\n            h[hindex++] = hh;\n        }\n    }\n    while (findex < flen) {\n        Qnew = Q + fnow;\n        bvirt = Qnew - Q;\n        hh = Q - (Qnew - bvirt) + (fnow - bvirt);\n        fnow = f[++findex];\n        Q = Qnew;\n        if (hh !== 0) {\n            h[hindex++] = hh;\n        }\n    }\n    if (Q !== 0 || hindex === 0) {\n        h[hindex++] = Q;\n    }\n    return hindex;\n}\n\nexport function sum_three(alen, a, blen, b, clen, c, tmp, out) {\n    return sum(sum(alen, a, blen, b, tmp), tmp, clen, c, out);\n}\n\n// scale_expansion_zeroelim routine from oritinal code\nexport function scale(elen, e, b, h) {\n    let Q, sum, hh, product1, product0;\n    let bvirt, c, ahi, alo, bhi, blo;\n\n    c = splitter * b;\n    bhi = c - (c - b);\n    blo = b - bhi;\n    let enow = e[0];\n    Q = enow * b;\n    c = splitter * enow;\n    ahi = c - (c - enow);\n    alo = enow - ahi;\n    hh = alo * blo - (Q - ahi * bhi - alo * bhi - ahi * blo);\n    let hindex = 0;\n    if (hh !== 0) {\n        h[hindex++] = hh;\n    }\n    for (let i = 1; i < elen; i++) {\n        enow = e[i];\n        product1 = enow * b;\n        c = splitter * enow;\n        ahi = c - (c - enow);\n        alo = enow - ahi;\n        product0 = alo * blo - (product1 - ahi * bhi - alo * bhi - ahi * blo);\n        sum = Q + product0;\n        bvirt = sum - Q;\n        hh = Q - (sum - bvirt) + (product0 - bvirt);\n        if (hh !== 0) {\n            h[hindex++] = hh;\n        }\n        Q = product1 + sum;\n        hh = sum - (Q - product1);\n        if (hh !== 0) {\n            h[hindex++] = hh;\n        }\n    }\n    if (Q !== 0 || hindex === 0) {\n        h[hindex++] = Q;\n    }\n    return hindex;\n}\n\nexport function negate(elen, e) {\n    for (let i = 0; i < elen; i++) e[i] = -e[i];\n    return elen;\n}\n\nexport function estimate(elen, e) {\n    let Q = e[0];\n    for (let i = 1; i < elen; i++) Q += e[i];\n    return Q;\n}\n\nexport function vec(n) {\n    return new Float64Array(n);\n}\n","import {epsilon, splitter, resulterrbound, estimate, vec, sum} from './util.js';\n\nconst ccwerrboundA = (3 + 16 * epsilon) * epsilon;\nconst ccwerrboundB = (2 + 12 * epsilon) * epsilon;\nconst ccwerrboundC = (9 + 64 * epsilon) * epsilon * epsilon;\n\nconst B = vec(4);\nconst C1 = vec(8);\nconst C2 = vec(12);\nconst D = vec(16);\nconst u = vec(4);\n\nfunction orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {\n    let acxtail, acytail, bcxtail, bcytail;\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;\n\n    const acx = ax - cx;\n    const bcx = bx - cx;\n    const acy = ay - cy;\n    const bcy = by - cy;\n\n    s1 = acx * bcy;\n    c = splitter * acx;\n    ahi = c - (c - acx);\n    alo = acx - ahi;\n    c = splitter * bcy;\n    bhi = c - (c - bcy);\n    blo = bcy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = acy * bcx;\n    c = splitter * acy;\n    ahi = c - (c - acy);\n    alo = acy - ahi;\n    c = splitter * bcx;\n    bhi = c - (c - bcx);\n    blo = bcx - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    B[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    B[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    B[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    B[3] = u3;\n\n    let det = estimate(4, B);\n    let errbound = ccwerrboundB * detsum;\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    bvirt = ax - acx;\n    acxtail = ax - (acx + bvirt) + (bvirt - cx);\n    bvirt = bx - bcx;\n    bcxtail = bx - (bcx + bvirt) + (bvirt - cx);\n    bvirt = ay - acy;\n    acytail = ay - (acy + bvirt) + (bvirt - cy);\n    bvirt = by - bcy;\n    bcytail = by - (bcy + bvirt) + (bvirt - cy);\n\n    if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) {\n        return det;\n    }\n\n    errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);\n    det += (acx * bcytail + bcy * acxtail) - (acy * bcxtail + bcx * acytail);\n    if (det >= errbound || -det >= errbound) return det;\n\n    s1 = acxtail * bcy;\n    c = splitter * acxtail;\n    ahi = c - (c - acxtail);\n    alo = acxtail - ahi;\n    c = splitter * bcy;\n    bhi = c - (c - bcy);\n    blo = bcy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = acytail * bcx;\n    c = splitter * acytail;\n    ahi = c - (c - acytail);\n    alo = acytail - ahi;\n    c = splitter * bcx;\n    bhi = c - (c - bcx);\n    blo = bcx - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    u[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    u[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    u[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    u[3] = u3;\n    const C1len = sum(4, B, 4, u, C1);\n\n    s1 = acx * bcytail;\n    c = splitter * acx;\n    ahi = c - (c - acx);\n    alo = acx - ahi;\n    c = splitter * bcytail;\n    bhi = c - (c - bcytail);\n    blo = bcytail - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = acy * bcxtail;\n    c = splitter * acy;\n    ahi = c - (c - acy);\n    alo = acy - ahi;\n    c = splitter * bcxtail;\n    bhi = c - (c - bcxtail);\n    blo = bcxtail - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    u[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    u[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    u[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    u[3] = u3;\n    const C2len = sum(C1len, C1, 4, u, C2);\n\n    s1 = acxtail * bcytail;\n    c = splitter * acxtail;\n    ahi = c - (c - acxtail);\n    alo = acxtail - ahi;\n    c = splitter * bcytail;\n    bhi = c - (c - bcytail);\n    blo = bcytail - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = acytail * bcxtail;\n    c = splitter * acytail;\n    ahi = c - (c - acytail);\n    alo = acytail - ahi;\n    c = splitter * bcxtail;\n    bhi = c - (c - bcxtail);\n    blo = bcxtail - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    u[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    u[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    u[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    u[3] = u3;\n    const Dlen = sum(C2len, C2, 4, u, D);\n\n    return D[Dlen - 1];\n}\n\nexport function orient2d(ax, ay, bx, by, cx, cy) {\n    const detleft = (ay - cy) * (bx - cx);\n    const detright = (ax - cx) * (by - cy);\n    const det = detleft - detright;\n\n    const detsum = Math.abs(detleft + detright);\n    if (Math.abs(det) >= ccwerrboundA * detsum) return det;\n\n    return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum);\n}\n\nexport function orient2dfast(ax, ay, bx, by, cx, cy) {\n    return (ay - cy) * (bx - cx) - (ax - cx) * (by - cy);\n}\n","import {epsilon, splitter, resulterrbound, estimate, vec, sum, scale} from './util.js';\n\nconst o3derrboundA = (7 + 56 * epsilon) * epsilon;\nconst o3derrboundB = (3 + 28 * epsilon) * epsilon;\nconst o3derrboundC = (26 + 288 * epsilon) * epsilon * epsilon;\n\nconst bc = vec(4);\nconst ca = vec(4);\nconst ab = vec(4);\nconst at_b = vec(4);\nconst at_c = vec(4);\nconst bt_c = vec(4);\nconst bt_a = vec(4);\nconst ct_a = vec(4);\nconst ct_b = vec(4);\nconst bct = vec(8);\nconst cat = vec(8);\nconst abt = vec(8);\nconst u = vec(4);\n\nconst _8 = vec(8);\nconst _8b = vec(8);\nconst _16 = vec(8);\nconst _12 = vec(12);\n\nlet fin = vec(192);\nlet fin2 = vec(192);\n\nfunction finadd(finlen, alen, a) {\n    finlen = sum(finlen, fin, alen, a, fin2);\n    const tmp = fin; fin = fin2; fin2 = tmp;\n    return finlen;\n}\n\nfunction tailinit(xtail, ytail, ax, ay, bx, by, a, b) {\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, t1, t0, u3, negate;\n    if (xtail === 0) {\n        if (ytail === 0) {\n            a[0] = 0;\n            b[0] = 0;\n            return 1;\n        } else {\n            negate = -ytail;\n            s1 = negate * ax;\n            c = splitter * negate;\n            ahi = c - (c - negate);\n            alo = negate - ahi;\n            c = splitter * ax;\n            bhi = c - (c - ax);\n            blo = ax - bhi;\n            a[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            a[1] = s1;\n            s1 = ytail * bx;\n            c = splitter * ytail;\n            ahi = c - (c - ytail);\n            alo = ytail - ahi;\n            c = splitter * bx;\n            bhi = c - (c - bx);\n            blo = bx - bhi;\n            b[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            b[1] = s1;\n            return 2;\n        }\n    } else {\n        if (ytail === 0) {\n            s1 = xtail * ay;\n            c = splitter * xtail;\n            ahi = c - (c - xtail);\n            alo = xtail - ahi;\n            c = splitter * ay;\n            bhi = c - (c - ay);\n            blo = ay - bhi;\n            a[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            a[1] = s1;\n            negate = -xtail;\n            s1 = negate * by;\n            c = splitter * negate;\n            ahi = c - (c - negate);\n            alo = negate - ahi;\n            c = splitter * by;\n            bhi = c - (c - by);\n            blo = by - bhi;\n            b[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            b[1] = s1;\n            return 2;\n        } else {\n            s1 = xtail * ay;\n            c = splitter * xtail;\n            ahi = c - (c - xtail);\n            alo = xtail - ahi;\n            c = splitter * ay;\n            bhi = c - (c - ay);\n            blo = ay - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = ytail * ax;\n            c = splitter * ytail;\n            ahi = c - (c - ytail);\n            alo = ytail - ahi;\n            c = splitter * ax;\n            bhi = c - (c - ax);\n            blo = ax - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 - t0;\n            bvirt = s0 - _i;\n            a[0] = s0 - (_i + bvirt) + (bvirt - t0);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 - t1;\n            bvirt = _0 - _i;\n            a[1] = _0 - (_i + bvirt) + (bvirt - t1);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            a[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            a[3] = u3;\n            s1 = ytail * bx;\n            c = splitter * ytail;\n            ahi = c - (c - ytail);\n            alo = ytail - ahi;\n            c = splitter * bx;\n            bhi = c - (c - bx);\n            blo = bx - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = xtail * by;\n            c = splitter * xtail;\n            ahi = c - (c - xtail);\n            alo = xtail - ahi;\n            c = splitter * by;\n            bhi = c - (c - by);\n            blo = by - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 - t0;\n            bvirt = s0 - _i;\n            b[0] = s0 - (_i + bvirt) + (bvirt - t0);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 - t1;\n            bvirt = _0 - _i;\n            b[1] = _0 - (_i + bvirt) + (bvirt - t1);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            b[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            b[3] = u3;\n            return 4;\n        }\n    }\n}\n\nfunction tailadd(finlen, a, b, k, z) {\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, u3;\n    s1 = a * b;\n    c = splitter * a;\n    ahi = c - (c - a);\n    alo = a - ahi;\n    c = splitter * b;\n    bhi = c - (c - b);\n    blo = b - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    c = splitter * k;\n    bhi = c - (c - k);\n    blo = k - bhi;\n    _i = s0 * k;\n    c = splitter * s0;\n    ahi = c - (c - s0);\n    alo = s0 - ahi;\n    u[0] = alo * blo - (_i - ahi * bhi - alo * bhi - ahi * blo);\n    _j = s1 * k;\n    c = splitter * s1;\n    ahi = c - (c - s1);\n    alo = s1 - ahi;\n    _0 = alo * blo - (_j - ahi * bhi - alo * bhi - ahi * blo);\n    _k = _i + _0;\n    bvirt = _k - _i;\n    u[1] = _i - (_k - bvirt) + (_0 - bvirt);\n    u3 = _j + _k;\n    u[2] = _k - (u3 - _j);\n    u[3] = u3;\n    finlen = finadd(finlen, 4, u);\n    if (z !== 0) {\n        c = splitter * z;\n        bhi = c - (c - z);\n        blo = z - bhi;\n        _i = s0 * z;\n        c = splitter * s0;\n        ahi = c - (c - s0);\n        alo = s0 - ahi;\n        u[0] = alo * blo - (_i - ahi * bhi - alo * bhi - ahi * blo);\n        _j = s1 * z;\n        c = splitter * s1;\n        ahi = c - (c - s1);\n        alo = s1 - ahi;\n        _0 = alo * blo - (_j - ahi * bhi - alo * bhi - ahi * blo);\n        _k = _i + _0;\n        bvirt = _k - _i;\n        u[1] = _i - (_k - bvirt) + (_0 - bvirt);\n        u3 = _j + _k;\n        u[2] = _k - (u3 - _j);\n        u[3] = u3;\n        finlen = finadd(finlen, 4, u);\n    }\n    return finlen;\n}\n\nfunction orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent) {\n    let finlen;\n    let adxtail, bdxtail, cdxtail;\n    let adytail, bdytail, cdytail;\n    let adztail, bdztail, cdztail;\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, t1, t0, u3;\n\n    const adx = ax - dx;\n    const bdx = bx - dx;\n    const cdx = cx - dx;\n    const ady = ay - dy;\n    const bdy = by - dy;\n    const cdy = cy - dy;\n    const adz = az - dz;\n    const bdz = bz - dz;\n    const cdz = cz - dz;\n\n    s1 = bdx * cdy;\n    c = splitter * bdx;\n    ahi = c - (c - bdx);\n    alo = bdx - ahi;\n    c = splitter * cdy;\n    bhi = c - (c - cdy);\n    blo = cdy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = cdx * bdy;\n    c = splitter * cdx;\n    ahi = c - (c - cdx);\n    alo = cdx - ahi;\n    c = splitter * bdy;\n    bhi = c - (c - bdy);\n    blo = bdy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    bc[3] = u3;\n    s1 = cdx * ady;\n    c = splitter * cdx;\n    ahi = c - (c - cdx);\n    alo = cdx - ahi;\n    c = splitter * ady;\n    bhi = c - (c - ady);\n    blo = ady - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = adx * cdy;\n    c = splitter * adx;\n    ahi = c - (c - adx);\n    alo = adx - ahi;\n    c = splitter * cdy;\n    bhi = c - (c - cdy);\n    blo = cdy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ca[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ca[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ca[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ca[3] = u3;\n    s1 = adx * bdy;\n    c = splitter * adx;\n    ahi = c - (c - adx);\n    alo = adx - ahi;\n    c = splitter * bdy;\n    bhi = c - (c - bdy);\n    blo = bdy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = bdx * ady;\n    c = splitter * bdx;\n    ahi = c - (c - bdx);\n    alo = bdx - ahi;\n    c = splitter * ady;\n    bhi = c - (c - ady);\n    blo = ady - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ab[3] = u3;\n\n    finlen = sum(\n        sum(\n            scale(4, bc, adz, _8), _8,\n            scale(4, ca, bdz, _8b), _8b, _16), _16,\n        scale(4, ab, cdz, _8), _8, fin);\n\n    let det = estimate(finlen, fin);\n    let errbound = o3derrboundB * permanent;\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    bvirt = ax - adx;\n    adxtail = ax - (adx + bvirt) + (bvirt - dx);\n    bvirt = bx - bdx;\n    bdxtail = bx - (bdx + bvirt) + (bvirt - dx);\n    bvirt = cx - cdx;\n    cdxtail = cx - (cdx + bvirt) + (bvirt - dx);\n    bvirt = ay - ady;\n    adytail = ay - (ady + bvirt) + (bvirt - dy);\n    bvirt = by - bdy;\n    bdytail = by - (bdy + bvirt) + (bvirt - dy);\n    bvirt = cy - cdy;\n    cdytail = cy - (cdy + bvirt) + (bvirt - dy);\n    bvirt = az - adz;\n    adztail = az - (adz + bvirt) + (bvirt - dz);\n    bvirt = bz - bdz;\n    bdztail = bz - (bdz + bvirt) + (bvirt - dz);\n    bvirt = cz - cdz;\n    cdztail = cz - (cdz + bvirt) + (bvirt - dz);\n\n    if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 &&\n        adytail === 0 && bdytail === 0 && cdytail === 0 &&\n        adztail === 0 && bdztail === 0 && cdztail === 0) {\n        return det;\n    }\n\n    errbound = o3derrboundC * permanent + resulterrbound * Math.abs(det);\n    det +=\n        adz * (bdx * cdytail + cdy * bdxtail - (bdy * cdxtail + cdx * bdytail)) + adztail * (bdx * cdy - bdy * cdx) +\n        bdz * (cdx * adytail + ady * cdxtail - (cdy * adxtail + adx * cdytail)) + bdztail * (cdx * ady - cdy * adx) +\n        cdz * (adx * bdytail + bdy * adxtail - (ady * bdxtail + bdx * adytail)) + cdztail * (adx * bdy - ady * bdx);\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    const at_len = tailinit(adxtail, adytail, bdx, bdy, cdx, cdy, at_b, at_c);\n    const bt_len = tailinit(bdxtail, bdytail, cdx, cdy, adx, ady, bt_c, bt_a);\n    const ct_len = tailinit(cdxtail, cdytail, adx, ady, bdx, bdy, ct_a, ct_b);\n\n    const bctlen = sum(bt_len, bt_c, ct_len, ct_b, bct);\n    finlen = finadd(finlen, scale(bctlen, bct, adz, _16), _16);\n\n    const catlen = sum(ct_len, ct_a, at_len, at_c, cat);\n    finlen = finadd(finlen, scale(catlen, cat, bdz, _16), _16);\n\n    const abtlen = sum(at_len, at_b, bt_len, bt_a, abt);\n    finlen = finadd(finlen, scale(abtlen, abt, cdz, _16), _16);\n\n    if (adztail !== 0) {\n        finlen = finadd(finlen, scale(4, bc, adztail, _12), _12);\n        finlen = finadd(finlen, scale(bctlen, bct, adztail, _16), _16);\n    }\n    if (bdztail !== 0) {\n        finlen = finadd(finlen, scale(4, ca, bdztail, _12), _12);\n        finlen = finadd(finlen, scale(catlen, cat, bdztail, _16), _16);\n    }\n    if (cdztail !== 0) {\n        finlen = finadd(finlen, scale(4, ab, cdztail, _12), _12);\n        finlen = finadd(finlen, scale(abtlen, abt, cdztail, _16), _16);\n    }\n\n    if (adxtail !== 0) {\n        if (bdytail !== 0) {\n            finlen = tailadd(finlen, adxtail, bdytail, cdz, cdztail);\n        }\n        if (cdytail !== 0) {\n            finlen = tailadd(finlen, -adxtail, cdytail, bdz, bdztail);\n        }\n    }\n    if (bdxtail !== 0) {\n        if (cdytail !== 0) {\n            finlen = tailadd(finlen, bdxtail, cdytail, adz, adztail);\n        }\n        if (adytail !== 0) {\n            finlen = tailadd(finlen, -bdxtail, adytail, cdz, cdztail);\n        }\n    }\n    if (cdxtail !== 0) {\n        if (adytail !== 0) {\n            finlen = tailadd(finlen, cdxtail, adytail, bdz, bdztail);\n        }\n        if (bdytail !== 0) {\n            finlen = tailadd(finlen, -cdxtail, bdytail, adz, adztail);\n        }\n    }\n\n    return fin[finlen - 1];\n}\n\nexport function orient3d(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {\n    const adx = ax - dx;\n    const bdx = bx - dx;\n    const cdx = cx - dx;\n    const ady = ay - dy;\n    const bdy = by - dy;\n    const cdy = cy - dy;\n    const adz = az - dz;\n    const bdz = bz - dz;\n    const cdz = cz - dz;\n\n    const bdxcdy = bdx * cdy;\n    const cdxbdy = cdx * bdy;\n\n    const cdxady = cdx * ady;\n    const adxcdy = adx * cdy;\n\n    const adxbdy = adx * bdy;\n    const bdxady = bdx * ady;\n\n    const det =\n        adz * (bdxcdy - cdxbdy) +\n        bdz * (cdxady - adxcdy) +\n        cdz * (adxbdy - bdxady);\n\n    const permanent =\n        (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * Math.abs(adz) +\n        (Math.abs(cdxady) + Math.abs(adxcdy)) * Math.abs(bdz) +\n        (Math.abs(adxbdy) + Math.abs(bdxady)) * Math.abs(cdz);\n\n    const errbound = o3derrboundA * permanent;\n    if (det > errbound || -det > errbound) {\n        return det;\n    }\n\n    return orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent);\n}\n\nexport function orient3dfast(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {\n    const adx = ax - dx;\n    const bdx = bx - dx;\n    const cdx = cx - dx;\n    const ady = ay - dy;\n    const bdy = by - dy;\n    const cdy = cy - dy;\n    const adz = az - dz;\n    const bdz = bz - dz;\n    const cdz = cz - dz;\n\n    return adx * (bdy * cdz - bdz * cdy) +\n        bdx * (cdy * adz - cdz * ady) +\n        cdx * (ady * bdz - adz * bdy);\n}\n","import {epsilon, splitter, resulterrbound, estimate, vec, sum, sum_three, scale} from './util.js';\n\nconst iccerrboundA = (10 + 96 * epsilon) * epsilon;\nconst iccerrboundB = (4 + 48 * epsilon) * epsilon;\nconst iccerrboundC = (44 + 576 * epsilon) * epsilon * epsilon;\n\nconst bc = vec(4);\nconst ca = vec(4);\nconst ab = vec(4);\nconst aa = vec(4);\nconst bb = vec(4);\nconst cc = vec(4);\nconst u = vec(4);\nconst v = vec(4);\nconst axtbc = vec(8);\nconst aytbc = vec(8);\nconst bxtca = vec(8);\nconst bytca = vec(8);\nconst cxtab = vec(8);\nconst cytab = vec(8);\nconst abt = vec(8);\nconst bct = vec(8);\nconst cat = vec(8);\nconst abtt = vec(4);\nconst bctt = vec(4);\nconst catt = vec(4);\n\nconst _8 = vec(8);\nconst _16 = vec(16);\nconst _16b = vec(16);\nconst _16c = vec(16);\nconst _32 = vec(32);\nconst _32b = vec(32);\nconst _48 = vec(48);\nconst _64 = vec(64);\n\nlet fin = vec(1152);\nlet fin2 = vec(1152);\n\nfunction finadd(finlen, a, alen) {\n    finlen = sum(finlen, fin, a, alen, fin2);\n    const tmp = fin; fin = fin2; fin2 = tmp;\n    return finlen;\n}\n\nfunction incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {\n    let finlen;\n    let adxtail, bdxtail, cdxtail, adytail, bdytail, cdytail;\n    let axtbclen, aytbclen, bxtcalen, bytcalen, cxtablen, cytablen;\n    let abtlen, bctlen, catlen;\n    let abttlen, bcttlen, cattlen;\n    let n1, n0;\n\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;\n\n    const adx = ax - dx;\n    const bdx = bx - dx;\n    const cdx = cx - dx;\n    const ady = ay - dy;\n    const bdy = by - dy;\n    const cdy = cy - dy;\n\n    s1 = bdx * cdy;\n    c = splitter * bdx;\n    ahi = c - (c - bdx);\n    alo = bdx - ahi;\n    c = splitter * cdy;\n    bhi = c - (c - cdy);\n    blo = cdy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = cdx * bdy;\n    c = splitter * cdx;\n    ahi = c - (c - cdx);\n    alo = cdx - ahi;\n    c = splitter * bdy;\n    bhi = c - (c - bdy);\n    blo = bdy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    bc[3] = u3;\n    s1 = cdx * ady;\n    c = splitter * cdx;\n    ahi = c - (c - cdx);\n    alo = cdx - ahi;\n    c = splitter * ady;\n    bhi = c - (c - ady);\n    blo = ady - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = adx * cdy;\n    c = splitter * adx;\n    ahi = c - (c - adx);\n    alo = adx - ahi;\n    c = splitter * cdy;\n    bhi = c - (c - cdy);\n    blo = cdy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ca[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ca[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ca[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ca[3] = u3;\n    s1 = adx * bdy;\n    c = splitter * adx;\n    ahi = c - (c - adx);\n    alo = adx - ahi;\n    c = splitter * bdy;\n    bhi = c - (c - bdy);\n    blo = bdy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = bdx * ady;\n    c = splitter * bdx;\n    ahi = c - (c - bdx);\n    alo = bdx - ahi;\n    c = splitter * ady;\n    bhi = c - (c - ady);\n    blo = ady - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ab[3] = u3;\n\n    finlen = sum(\n        sum(\n            sum(\n                scale(scale(4, bc, adx, _8), _8, adx, _16), _16,\n                scale(scale(4, bc, ady, _8), _8, ady, _16b), _16b, _32), _32,\n            sum(\n                scale(scale(4, ca, bdx, _8), _8, bdx, _16), _16,\n                scale(scale(4, ca, bdy, _8), _8, bdy, _16b), _16b, _32b), _32b, _64), _64,\n        sum(\n            scale(scale(4, ab, cdx, _8), _8, cdx, _16), _16,\n            scale(scale(4, ab, cdy, _8), _8, cdy, _16b), _16b, _32), _32, fin);\n\n    let det = estimate(finlen, fin);\n    let errbound = iccerrboundB * permanent;\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    bvirt = ax - adx;\n    adxtail = ax - (adx + bvirt) + (bvirt - dx);\n    bvirt = ay - ady;\n    adytail = ay - (ady + bvirt) + (bvirt - dy);\n    bvirt = bx - bdx;\n    bdxtail = bx - (bdx + bvirt) + (bvirt - dx);\n    bvirt = by - bdy;\n    bdytail = by - (bdy + bvirt) + (bvirt - dy);\n    bvirt = cx - cdx;\n    cdxtail = cx - (cdx + bvirt) + (bvirt - dx);\n    bvirt = cy - cdy;\n    cdytail = cy - (cdy + bvirt) + (bvirt - dy);\n    if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 && adytail === 0 && bdytail === 0 && cdytail === 0) {\n        return det;\n    }\n\n    errbound = iccerrboundC * permanent + resulterrbound * Math.abs(det);\n    det += ((adx * adx + ady * ady) * ((bdx * cdytail + cdy * bdxtail) - (bdy * cdxtail + cdx * bdytail)) +\n        2 * (adx * adxtail + ady * adytail) * (bdx * cdy - bdy * cdx)) +\n        ((bdx * bdx + bdy * bdy) * ((cdx * adytail + ady * cdxtail) - (cdy * adxtail + adx * cdytail)) +\n        2 * (bdx * bdxtail + bdy * bdytail) * (cdx * ady - cdy * adx)) +\n        ((cdx * cdx + cdy * cdy) * ((adx * bdytail + bdy * adxtail) - (ady * bdxtail + bdx * adytail)) +\n        2 * (cdx * cdxtail + cdy * cdytail) * (adx * bdy - ady * bdx));\n\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {\n        s1 = adx * adx;\n        c = splitter * adx;\n        ahi = c - (c - adx);\n        alo = adx - ahi;\n        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);\n        t1 = ady * ady;\n        c = splitter * ady;\n        ahi = c - (c - ady);\n        alo = ady - ahi;\n        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);\n        _i = s0 + t0;\n        bvirt = _i - s0;\n        aa[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n        _j = s1 + _i;\n        bvirt = _j - s1;\n        _0 = s1 - (_j - bvirt) + (_i - bvirt);\n        _i = _0 + t1;\n        bvirt = _i - _0;\n        aa[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n        u3 = _j + _i;\n        bvirt = u3 - _j;\n        aa[2] = _j - (u3 - bvirt) + (_i - bvirt);\n        aa[3] = u3;\n    }\n    if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {\n        s1 = bdx * bdx;\n        c = splitter * bdx;\n        ahi = c - (c - bdx);\n        alo = bdx - ahi;\n        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);\n        t1 = bdy * bdy;\n        c = splitter * bdy;\n        ahi = c - (c - bdy);\n        alo = bdy - ahi;\n        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);\n        _i = s0 + t0;\n        bvirt = _i - s0;\n        bb[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n        _j = s1 + _i;\n        bvirt = _j - s1;\n        _0 = s1 - (_j - bvirt) + (_i - bvirt);\n        _i = _0 + t1;\n        bvirt = _i - _0;\n        bb[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n        u3 = _j + _i;\n        bvirt = u3 - _j;\n        bb[2] = _j - (u3 - bvirt) + (_i - bvirt);\n        bb[3] = u3;\n    }\n    if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {\n        s1 = cdx * cdx;\n        c = splitter * cdx;\n        ahi = c - (c - cdx);\n        alo = cdx - ahi;\n        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);\n        t1 = cdy * cdy;\n        c = splitter * cdy;\n        ahi = c - (c - cdy);\n        alo = cdy - ahi;\n        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);\n        _i = s0 + t0;\n        bvirt = _i - s0;\n        cc[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n        _j = s1 + _i;\n        bvirt = _j - s1;\n        _0 = s1 - (_j - bvirt) + (_i - bvirt);\n        _i = _0 + t1;\n        bvirt = _i - _0;\n        cc[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n        u3 = _j + _i;\n        bvirt = u3 - _j;\n        cc[2] = _j - (u3 - bvirt) + (_i - bvirt);\n        cc[3] = u3;\n    }\n\n    if (adxtail !== 0) {\n        axtbclen = scale(4, bc, adxtail, axtbc);\n        finlen = finadd(finlen, sum_three(\n            scale(axtbclen, axtbc, 2 * adx, _16), _16,\n            scale(scale(4, cc, adxtail, _8), _8, bdy, _16b), _16b,\n            scale(scale(4, bb, adxtail, _8), _8, -cdy, _16c), _16c, _32, _48), _48);\n    }\n    if (adytail !== 0) {\n        aytbclen = scale(4, bc, adytail, aytbc);\n        finlen = finadd(finlen, sum_three(\n            scale(aytbclen, aytbc, 2 * ady, _16), _16,\n            scale(scale(4, bb, adytail, _8), _8, cdx, _16b), _16b,\n            scale(scale(4, cc, adytail, _8), _8, -bdx, _16c), _16c, _32, _48), _48);\n    }\n    if (bdxtail !== 0) {\n        bxtcalen = scale(4, ca, bdxtail, bxtca);\n        finlen = finadd(finlen, sum_three(\n            scale(bxtcalen, bxtca, 2 * bdx, _16), _16,\n            scale(scale(4, aa, bdxtail, _8), _8, cdy, _16b), _16b,\n            scale(scale(4, cc, bdxtail, _8), _8, -ady, _16c), _16c, _32, _48), _48);\n    }\n    if (bdytail !== 0) {\n        bytcalen = scale(4, ca, bdytail, bytca);\n        finlen = finadd(finlen, sum_three(\n            scale(bytcalen, bytca, 2 * bdy, _16), _16,\n            scale(scale(4, cc, bdytail, _8), _8, adx, _16b), _16b,\n            scale(scale(4, aa, bdytail, _8), _8, -cdx, _16c), _16c, _32, _48), _48);\n    }\n    if (cdxtail !== 0) {\n        cxtablen = scale(4, ab, cdxtail, cxtab);\n        finlen = finadd(finlen, sum_three(\n            scale(cxtablen, cxtab, 2 * cdx, _16), _16,\n            scale(scale(4, bb, cdxtail, _8), _8, ady, _16b), _16b,\n            scale(scale(4, aa, cdxtail, _8), _8, -bdy, _16c), _16c, _32, _48), _48);\n    }\n    if (cdytail !== 0) {\n        cytablen = scale(4, ab, cdytail, cytab);\n        finlen = finadd(finlen, sum_three(\n            scale(cytablen, cytab, 2 * cdy, _16), _16,\n            scale(scale(4, aa, cdytail, _8), _8, bdx, _16b), _16b,\n            scale(scale(4, bb, cdytail, _8), _8, -adx, _16c), _16c, _32, _48), _48);\n    }\n\n    if (adxtail !== 0 || adytail !== 0) {\n        if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {\n            s1 = bdxtail * cdy;\n            c = splitter * bdxtail;\n            ahi = c - (c - bdxtail);\n            alo = bdxtail - ahi;\n            c = splitter * cdy;\n            bhi = c - (c - cdy);\n            blo = cdy - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = bdx * cdytail;\n            c = splitter * bdx;\n            ahi = c - (c - bdx);\n            alo = bdx - ahi;\n            c = splitter * cdytail;\n            bhi = c - (c - cdytail);\n            blo = cdytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 + t0;\n            bvirt = _i - s0;\n            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 + t1;\n            bvirt = _i - _0;\n            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            u[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            u[3] = u3;\n            s1 = cdxtail * -bdy;\n            c = splitter * cdxtail;\n            ahi = c - (c - cdxtail);\n            alo = cdxtail - ahi;\n            c = splitter * -bdy;\n            bhi = c - (c - -bdy);\n            blo = -bdy - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = cdx * -bdytail;\n            c = splitter * cdx;\n            ahi = c - (c - cdx);\n            alo = cdx - ahi;\n            c = splitter * -bdytail;\n            bhi = c - (c - -bdytail);\n            blo = -bdytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 + t0;\n            bvirt = _i - s0;\n            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 + t1;\n            bvirt = _i - _0;\n            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            v[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            v[3] = u3;\n            bctlen = sum(4, u, 4, v, bct);\n            s1 = bdxtail * cdytail;\n            c = splitter * bdxtail;\n            ahi = c - (c - bdxtail);\n            alo = bdxtail - ahi;\n            c = splitter * cdytail;\n            bhi = c - (c - cdytail);\n            blo = cdytail - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = cdxtail * bdytail;\n            c = splitter * cdxtail;\n            ahi = c - (c - cdxtail);\n            alo = cdxtail - ahi;\n            c = splitter * bdytail;\n            bhi = c - (c - bdytail);\n            blo = bdytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 - t0;\n            bvirt = s0 - _i;\n            bctt[0] = s0 - (_i + bvirt) + (bvirt - t0);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 - t1;\n            bvirt = _0 - _i;\n            bctt[1] = _0 - (_i + bvirt) + (bvirt - t1);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            bctt[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            bctt[3] = u3;\n            bcttlen = 4;\n        } else {\n            bct[0] = 0;\n            bctlen = 1;\n            bctt[0] = 0;\n            bcttlen = 1;\n        }\n        if (adxtail !== 0) {\n            const len = scale(bctlen, bct, adxtail, _16c);\n            finlen = finadd(finlen, sum(\n                scale(axtbclen, axtbc, adxtail, _16), _16,\n                scale(len, _16c, 2 * adx, _32), _32, _48), _48);\n\n            const len2 = scale(bcttlen, bctt, adxtail, _8);\n            finlen = finadd(finlen, sum_three(\n                scale(len2, _8, 2 * adx, _16), _16,\n                scale(len2, _8, adxtail, _16b), _16b,\n                scale(len, _16c, adxtail, _32), _32, _32b, _64), _64);\n\n            if (bdytail !== 0) {\n                finlen = finadd(finlen, scale(scale(4, cc, adxtail, _8), _8, bdytail, _16), _16);\n            }\n            if (cdytail !== 0) {\n                finlen = finadd(finlen, scale(scale(4, bb, -adxtail, _8), _8, cdytail, _16), _16);\n            }\n        }\n        if (adytail !== 0) {\n            const len = scale(bctlen, bct, adytail, _16c);\n            finlen = finadd(finlen, sum(\n                scale(aytbclen, aytbc, adytail, _16), _16,\n                scale(len, _16c, 2 * ady, _32), _32, _48), _48);\n\n            const len2 = scale(bcttlen, bctt, adytail, _8);\n            finlen = finadd(finlen, sum_three(\n                scale(len2, _8, 2 * ady, _16), _16,\n                scale(len2, _8, adytail, _16b), _16b,\n                scale(len, _16c, adytail, _32), _32, _32b, _64), _64);\n        }\n    }\n    if (bdxtail !== 0 || bdytail !== 0) {\n        if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {\n            s1 = cdxtail * ady;\n            c = splitter * cdxtail;\n            ahi = c - (c - cdxtail);\n            alo = cdxtail - ahi;\n            c = splitter * ady;\n            bhi = c - (c - ady);\n            blo = ady - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = cdx * adytail;\n            c = splitter * cdx;\n            ahi = c - (c - cdx);\n            alo = cdx - ahi;\n            c = splitter * adytail;\n            bhi = c - (c - adytail);\n            blo = adytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 + t0;\n            bvirt = _i - s0;\n            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 + t1;\n            bvirt = _i - _0;\n            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            u[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            u[3] = u3;\n            n1 = -cdy;\n            n0 = -cdytail;\n            s1 = adxtail * n1;\n            c = splitter * adxtail;\n            ahi = c - (c - adxtail);\n            alo = adxtail - ahi;\n            c = splitter * n1;\n            bhi = c - (c - n1);\n            blo = n1 - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = adx * n0;\n            c = splitter * adx;\n            ahi = c - (c - adx);\n            alo = adx - ahi;\n            c = splitter * n0;\n            bhi = c - (c - n0);\n            blo = n0 - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 + t0;\n            bvirt = _i - s0;\n            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 + t1;\n            bvirt = _i - _0;\n            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            v[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            v[3] = u3;\n            catlen = sum(4, u, 4, v, cat);\n            s1 = cdxtail * adytail;\n            c = splitter * cdxtail;\n            ahi = c - (c - cdxtail);\n            alo = cdxtail - ahi;\n            c = splitter * adytail;\n            bhi = c - (c - adytail);\n            blo = adytail - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = adxtail * cdytail;\n            c = splitter * adxtail;\n            ahi = c - (c - adxtail);\n            alo = adxtail - ahi;\n            c = splitter * cdytail;\n            bhi = c - (c - cdytail);\n            blo = cdytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 - t0;\n            bvirt = s0 - _i;\n            catt[0] = s0 - (_i + bvirt) + (bvirt - t0);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 - t1;\n            bvirt = _0 - _i;\n            catt[1] = _0 - (_i + bvirt) + (bvirt - t1);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            catt[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            catt[3] = u3;\n            cattlen = 4;\n        } else {\n            cat[0] = 0;\n            catlen = 1;\n            catt[0] = 0;\n            cattlen = 1;\n        }\n        if (bdxtail !== 0) {\n            const len = scale(catlen, cat, bdxtail, _16c);\n            finlen = finadd(finlen, sum(\n                scale(bxtcalen, bxtca, bdxtail, _16), _16,\n                scale(len, _16c, 2 * bdx, _32), _32, _48), _48);\n\n            const len2 = scale(cattlen, catt, bdxtail, _8);\n            finlen = finadd(finlen, sum_three(\n                scale(len2, _8, 2 * bdx, _16), _16,\n                scale(len2, _8, bdxtail, _16b), _16b,\n                scale(len, _16c, bdxtail, _32), _32, _32b, _64), _64);\n\n            if (cdytail !== 0) {\n                finlen = finadd(finlen, scale(scale(4, aa, bdxtail, _8), _8, cdytail, _16), _16);\n            }\n            if (adytail !== 0) {\n                finlen = finadd(finlen, scale(scale(4, cc, -bdxtail, _8), _8, adytail, _16), _16);\n            }\n        }\n        if (bdytail !== 0) {\n            const len = scale(catlen, cat, bdytail, _16c);\n            finlen = finadd(finlen, sum(\n                scale(bytcalen, bytca, bdytail, _16), _16,\n                scale(len, _16c, 2 * bdy, _32), _32, _48), _48);\n\n            const len2 = scale(cattlen, catt, bdytail, _8);\n            finlen = finadd(finlen, sum_three(\n                scale(len2, _8, 2 * bdy, _16), _16,\n                scale(len2, _8, bdytail, _16b), _16b,\n                scale(len, _16c, bdytail, _32), _32,  _32b, _64), _64);\n        }\n    }\n    if (cdxtail !== 0 || cdytail !== 0) {\n        if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {\n            s1 = adxtail * bdy;\n            c = splitter * adxtail;\n            ahi = c - (c - adxtail);\n            alo = adxtail - ahi;\n            c = splitter * bdy;\n            bhi = c - (c - bdy);\n            blo = bdy - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = adx * bdytail;\n            c = splitter * adx;\n            ahi = c - (c - adx);\n            alo = adx - ahi;\n            c = splitter * bdytail;\n            bhi = c - (c - bdytail);\n            blo = bdytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 + t0;\n            bvirt = _i - s0;\n            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 + t1;\n            bvirt = _i - _0;\n            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            u[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            u[3] = u3;\n            n1 = -ady;\n            n0 = -adytail;\n            s1 = bdxtail * n1;\n            c = splitter * bdxtail;\n            ahi = c - (c - bdxtail);\n            alo = bdxtail - ahi;\n            c = splitter * n1;\n            bhi = c - (c - n1);\n            blo = n1 - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = bdx * n0;\n            c = splitter * bdx;\n            ahi = c - (c - bdx);\n            alo = bdx - ahi;\n            c = splitter * n0;\n            bhi = c - (c - n0);\n            blo = n0 - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 + t0;\n            bvirt = _i - s0;\n            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 + t1;\n            bvirt = _i - _0;\n            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            v[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            v[3] = u3;\n            abtlen = sum(4, u, 4, v, abt);\n            s1 = adxtail * bdytail;\n            c = splitter * adxtail;\n            ahi = c - (c - adxtail);\n            alo = adxtail - ahi;\n            c = splitter * bdytail;\n            bhi = c - (c - bdytail);\n            blo = bdytail - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = bdxtail * adytail;\n            c = splitter * bdxtail;\n            ahi = c - (c - bdxtail);\n            alo = bdxtail - ahi;\n            c = splitter * adytail;\n            bhi = c - (c - adytail);\n            blo = adytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 - t0;\n            bvirt = s0 - _i;\n            abtt[0] = s0 - (_i + bvirt) + (bvirt - t0);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 - t1;\n            bvirt = _0 - _i;\n            abtt[1] = _0 - (_i + bvirt) + (bvirt - t1);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            abtt[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            abtt[3] = u3;\n            abttlen = 4;\n        } else {\n            abt[0] = 0;\n            abtlen = 1;\n            abtt[0] = 0;\n            abttlen = 1;\n        }\n        if (cdxtail !== 0) {\n            const len = scale(abtlen, abt, cdxtail, _16c);\n            finlen = finadd(finlen, sum(\n                scale(cxtablen, cxtab, cdxtail, _16), _16,\n                scale(len, _16c, 2 * cdx, _32), _32, _48), _48);\n\n            const len2 = scale(abttlen, abtt, cdxtail, _8);\n            finlen = finadd(finlen, sum_three(\n                scale(len2, _8, 2 * cdx, _16), _16,\n                scale(len2, _8, cdxtail, _16b), _16b,\n                scale(len, _16c, cdxtail, _32), _32, _32b, _64), _64);\n\n            if (adytail !== 0) {\n                finlen = finadd(finlen, scale(scale(4, bb, cdxtail, _8), _8, adytail, _16), _16);\n            }\n            if (bdytail !== 0) {\n                finlen = finadd(finlen, scale(scale(4, aa, -cdxtail, _8), _8, bdytail, _16), _16);\n            }\n        }\n        if (cdytail !== 0) {\n            const len = scale(abtlen, abt, cdytail, _16c);\n            finlen = finadd(finlen, sum(\n                scale(cytablen, cytab, cdytail, _16), _16,\n                scale(len, _16c, 2 * cdy, _32), _32, _48), _48);\n\n            const len2 = scale(abttlen, abtt, cdytail, _8);\n            finlen = finadd(finlen, sum_three(\n                scale(len2, _8, 2 * cdy, _16), _16,\n                scale(len2, _8, cdytail, _16b), _16b,\n                scale(len, _16c, cdytail, _32), _32, _32b, _64), _64);\n        }\n    }\n\n    return fin[finlen - 1];\n}\n\nexport function incircle(ax, ay, bx, by, cx, cy, dx, dy) {\n    const adx = ax - dx;\n    const bdx = bx - dx;\n    const cdx = cx - dx;\n    const ady = ay - dy;\n    const bdy = by - dy;\n    const cdy = cy - dy;\n\n    const bdxcdy = bdx * cdy;\n    const cdxbdy = cdx * bdy;\n    const alift = adx * adx + ady * ady;\n\n    const cdxady = cdx * ady;\n    const adxcdy = adx * cdy;\n    const blift = bdx * bdx + bdy * bdy;\n\n    const adxbdy = adx * bdy;\n    const bdxady = bdx * ady;\n    const clift = cdx * cdx + cdy * cdy;\n\n    const det =\n        alift * (bdxcdy - cdxbdy) +\n        blift * (cdxady - adxcdy) +\n        clift * (adxbdy - bdxady);\n\n    const permanent =\n        (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * alift +\n        (Math.abs(cdxady) + Math.abs(adxcdy)) * blift +\n        (Math.abs(adxbdy) + Math.abs(bdxady)) * clift;\n\n    const errbound = iccerrboundA * permanent;\n\n    if (det > errbound || -det > errbound) {\n        return det;\n    }\n    return incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent);\n}\n\nexport function incirclefast(ax, ay, bx, by, cx, cy, dx, dy) {\n    const adx = ax - dx;\n    const ady = ay - dy;\n    const bdx = bx - dx;\n    const bdy = by - dy;\n    const cdx = cx - dx;\n    const cdy = cy - dy;\n\n    const abdet = adx * bdy - bdx * ady;\n    const bcdet = bdx * cdy - cdx * bdy;\n    const cadet = cdx * ady - adx * cdy;\n    const alift = adx * adx + ady * ady;\n    const blift = bdx * bdx + bdy * bdy;\n    const clift = cdx * cdx + cdy * cdy;\n\n    return alift * bcdet + blift * cadet + clift * abdet;\n}\n","import {epsilon, splitter, resulterrbound, estimate, vec, sum, sum_three, scale, negate} from './util.js';\n\nconst isperrboundA = (16 + 224 * epsilon) * epsilon;\nconst isperrboundB = (5 + 72 * epsilon) * epsilon;\nconst isperrboundC = (71 + 1408 * epsilon) * epsilon * epsilon;\n\nconst ab = vec(4);\nconst bc = vec(4);\nconst cd = vec(4);\nconst de = vec(4);\nconst ea = vec(4);\nconst ac = vec(4);\nconst bd = vec(4);\nconst ce = vec(4);\nconst da = vec(4);\nconst eb = vec(4);\n\nconst abc = vec(24);\nconst bcd = vec(24);\nconst cde = vec(24);\nconst dea = vec(24);\nconst eab = vec(24);\nconst abd = vec(24);\nconst bce = vec(24);\nconst cda = vec(24);\nconst deb = vec(24);\nconst eac = vec(24);\n\nconst adet = vec(1152);\nconst bdet = vec(1152);\nconst cdet = vec(1152);\nconst ddet = vec(1152);\nconst edet = vec(1152);\nconst abdet = vec(2304);\nconst cddet = vec(2304);\nconst cdedet = vec(3456);\nconst deter = vec(5760);\n\nconst _8 = vec(8);\nconst _8b = vec(8);\nconst _8c = vec(8);\nconst _16 = vec(16);\nconst _24 = vec(24);\nconst _48 = vec(48);\nconst _48b = vec(48);\nconst _96 = vec(96);\nconst _192 = vec(192);\nconst _384x = vec(384);\nconst _384y = vec(384);\nconst _384z = vec(384);\nconst _768 = vec(768);\n\nfunction sum_three_scale(a, b, c, az, bz, cz, out) {\n    return sum_three(\n        scale(4, a, az, _8), _8,\n        scale(4, b, bz, _8b), _8b,\n        scale(4, c, cz, _8c), _8c, _16, out);\n}\n\nfunction liftexact(alen, a, blen, b, clen, c, dlen, d, x, y, z, out) {\n    const len = sum(\n        sum(alen, a, blen, b, _48), _48,\n        negate(sum(clen, c, dlen, d, _48b), _48b), _48b, _96);\n\n    return sum_three(\n        scale(scale(len, _96, x, _192), _192, x, _384x), _384x,\n        scale(scale(len, _96, y, _192), _192, y, _384y), _384y,\n        scale(scale(len, _96, z, _192), _192, z, _384z), _384z, _768, out);\n}\n\nfunction insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;\n\n    s1 = ax * by;\n    c = splitter * ax;\n    ahi = c - (c - ax);\n    alo = ax - ahi;\n    c = splitter * by;\n    bhi = c - (c - by);\n    blo = by - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = bx * ay;\n    c = splitter * bx;\n    ahi = c - (c - bx);\n    alo = bx - ahi;\n    c = splitter * ay;\n    bhi = c - (c - ay);\n    blo = ay - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ab[3] = u3;\n    s1 = bx * cy;\n    c = splitter * bx;\n    ahi = c - (c - bx);\n    alo = bx - ahi;\n    c = splitter * cy;\n    bhi = c - (c - cy);\n    blo = cy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = cx * by;\n    c = splitter * cx;\n    ahi = c - (c - cx);\n    alo = cx - ahi;\n    c = splitter * by;\n    bhi = c - (c - by);\n    blo = by - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    bc[3] = u3;\n    s1 = cx * dy;\n    c = splitter * cx;\n    ahi = c - (c - cx);\n    alo = cx - ahi;\n    c = splitter * dy;\n    bhi = c - (c - dy);\n    blo = dy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = dx * cy;\n    c = splitter * dx;\n    ahi = c - (c - dx);\n    alo = dx - ahi;\n    c = splitter * cy;\n    bhi = c - (c - cy);\n    blo = cy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    cd[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    cd[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    cd[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    cd[3] = u3;\n    s1 = dx * ey;\n    c = splitter * dx;\n    ahi = c - (c - dx);\n    alo = dx - ahi;\n    c = splitter * ey;\n    bhi = c - (c - ey);\n    blo = ey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = ex * dy;\n    c = splitter * ex;\n    ahi = c - (c - ex);\n    alo = ex - ahi;\n    c = splitter * dy;\n    bhi = c - (c - dy);\n    blo = dy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    de[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    de[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    de[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    de[3] = u3;\n    s1 = ex * ay;\n    c = splitter * ex;\n    ahi = c - (c - ex);\n    alo = ex - ahi;\n    c = splitter * ay;\n    bhi = c - (c - ay);\n    blo = ay - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = ax * ey;\n    c = splitter * ax;\n    ahi = c - (c - ax);\n    alo = ax - ahi;\n    c = splitter * ey;\n    bhi = c - (c - ey);\n    blo = ey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ea[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ea[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ea[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ea[3] = u3;\n    s1 = ax * cy;\n    c = splitter * ax;\n    ahi = c - (c - ax);\n    alo = ax - ahi;\n    c = splitter * cy;\n    bhi = c - (c - cy);\n    blo = cy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = cx * ay;\n    c = splitter * cx;\n    ahi = c - (c - cx);\n    alo = cx - ahi;\n    c = splitter * ay;\n    bhi = c - (c - ay);\n    blo = ay - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ac[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ac[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ac[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ac[3] = u3;\n    s1 = bx * dy;\n    c = splitter * bx;\n    ahi = c - (c - bx);\n    alo = bx - ahi;\n    c = splitter * dy;\n    bhi = c - (c - dy);\n    blo = dy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = dx * by;\n    c = splitter * dx;\n    ahi = c - (c - dx);\n    alo = dx - ahi;\n    c = splitter * by;\n    bhi = c - (c - by);\n    blo = by - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    bd[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    bd[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    bd[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    bd[3] = u3;\n    s1 = cx * ey;\n    c = splitter * cx;\n    ahi = c - (c - cx);\n    alo = cx - ahi;\n    c = splitter * ey;\n    bhi = c - (c - ey);\n    blo = ey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = ex * cy;\n    c = splitter * ex;\n    ahi = c - (c - ex);\n    alo = ex - ahi;\n    c = splitter * cy;\n    bhi = c - (c - cy);\n    blo = cy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ce[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ce[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ce[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ce[3] = u3;\n    s1 = dx * ay;\n    c = splitter * dx;\n    ahi = c - (c - dx);\n    alo = dx - ahi;\n    c = splitter * ay;\n    bhi = c - (c - ay);\n    blo = ay - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = ax * dy;\n    c = splitter * ax;\n    ahi = c - (c - ax);\n    alo = ax - ahi;\n    c = splitter * dy;\n    bhi = c - (c - dy);\n    blo = dy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    da[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    da[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    da[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    da[3] = u3;\n    s1 = ex * by;\n    c = splitter * ex;\n    ahi = c - (c - ex);\n    alo = ex - ahi;\n    c = splitter * by;\n    bhi = c - (c - by);\n    blo = by - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = bx * ey;\n    c = splitter * bx;\n    ahi = c - (c - bx);\n    alo = bx - ahi;\n    c = splitter * ey;\n    bhi = c - (c - ey);\n    blo = ey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    eb[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    eb[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    eb[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    eb[3] = u3;\n\n    const abclen = sum_three_scale(ab, bc, ac, cz, az, -bz, abc);\n    const bcdlen = sum_three_scale(bc, cd, bd, dz, bz, -cz, bcd);\n    const cdelen = sum_three_scale(cd, de, ce, ez, cz, -dz, cde);\n    const dealen = sum_three_scale(de, ea, da, az, dz, -ez, dea);\n    const eablen = sum_three_scale(ea, ab, eb, bz, ez, -az, eab);\n    const abdlen = sum_three_scale(ab, bd, da, dz, az, bz, abd);\n    const bcelen = sum_three_scale(bc, ce, eb, ez, bz, cz, bce);\n    const cdalen = sum_three_scale(cd, da, ac, az, cz, dz, cda);\n    const deblen = sum_three_scale(de, eb, bd, bz, dz, ez, deb);\n    const eaclen = sum_three_scale(ea, ac, ce, cz, ez, az, eac);\n\n    const deterlen = sum_three(\n        liftexact(cdelen, cde, bcelen, bce, deblen, deb, bcdlen, bcd, ax, ay, az, adet), adet,\n        liftexact(dealen, dea, cdalen, cda, eaclen, eac, cdelen, cde, bx, by, bz, bdet), bdet,\n        sum_three(\n            liftexact(eablen, eab, deblen, deb, abdlen, abd, dealen, dea, cx, cy, cz, cdet), cdet,\n            liftexact(abclen, abc, eaclen, eac, bcelen, bce, eablen, eab, dx, dy, dz, ddet), ddet,\n            liftexact(bcdlen, bcd, abdlen, abd, cdalen, cda, abclen, abc, ex, ey, ez, edet), edet, cddet, cdedet), cdedet, abdet, deter);\n\n    return deter[deterlen - 1];\n}\n\nconst xdet = vec(96);\nconst ydet = vec(96);\nconst zdet = vec(96);\nconst fin = vec(1152);\n\nfunction liftadapt(a, b, c, az, bz, cz, x, y, z, out) {\n    const len = sum_three_scale(a, b, c, az, bz, cz, _24);\n    return sum_three(\n        scale(scale(len, _24, x, _48), _48, x, xdet), xdet,\n        scale(scale(len, _24, y, _48), _48, y, ydet), ydet,\n        scale(scale(len, _24, z, _48), _48, z, zdet), zdet, _192, out);\n}\n\nfunction insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez, permanent) {\n    let ab3, bc3, cd3, da3, ac3, bd3;\n\n    let aextail, bextail, cextail, dextail;\n    let aeytail, beytail, ceytail, deytail;\n    let aeztail, beztail, ceztail, deztail;\n\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0;\n\n    const aex = ax - ex;\n    const bex = bx - ex;\n    const cex = cx - ex;\n    const dex = dx - ex;\n    const aey = ay - ey;\n    const bey = by - ey;\n    const cey = cy - ey;\n    const dey = dy - ey;\n    const aez = az - ez;\n    const bez = bz - ez;\n    const cez = cz - ez;\n    const dez = dz - ez;\n\n    s1 = aex * bey;\n    c = splitter * aex;\n    ahi = c - (c - aex);\n    alo = aex - ahi;\n    c = splitter * bey;\n    bhi = c - (c - bey);\n    blo = bey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = bex * aey;\n    c = splitter * bex;\n    ahi = c - (c - bex);\n    alo = bex - ahi;\n    c = splitter * aey;\n    bhi = c - (c - aey);\n    blo = aey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    ab3 = _j + _i;\n    bvirt = ab3 - _j;\n    ab[2] = _j - (ab3 - bvirt) + (_i - bvirt);\n    ab[3] = ab3;\n    s1 = bex * cey;\n    c = splitter * bex;\n    ahi = c - (c - bex);\n    alo = bex - ahi;\n    c = splitter * cey;\n    bhi = c - (c - cey);\n    blo = cey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = cex * bey;\n    c = splitter * cex;\n    ahi = c - (c - cex);\n    alo = cex - ahi;\n    c = splitter * bey;\n    bhi = c - (c - bey);\n    blo = bey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    bc3 = _j + _i;\n    bvirt = bc3 - _j;\n    bc[2] = _j - (bc3 - bvirt) + (_i - bvirt);\n    bc[3] = bc3;\n    s1 = cex * dey;\n    c = splitter * cex;\n    ahi = c - (c - cex);\n    alo = cex - ahi;\n    c = splitter * dey;\n    bhi = c - (c - dey);\n    blo = dey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = dex * cey;\n    c = splitter * dex;\n    ahi = c - (c - dex);\n    alo = dex - ahi;\n    c = splitter * cey;\n    bhi = c - (c - cey);\n    blo = cey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    cd[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    cd[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    cd3 = _j + _i;\n    bvirt = cd3 - _j;\n    cd[2] = _j - (cd3 - bvirt) + (_i - bvirt);\n    cd[3] = cd3;\n    s1 = dex * aey;\n    c = splitter * dex;\n    ahi = c - (c - dex);\n    alo = dex - ahi;\n    c = splitter * aey;\n    bhi = c - (c - aey);\n    blo = aey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = aex * dey;\n    c = splitter * aex;\n    ahi = c - (c - aex);\n    alo = aex - ahi;\n    c = splitter * dey;\n    bhi = c - (c - dey);\n    blo = dey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    da[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    da[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    da3 = _j + _i;\n    bvirt = da3 - _j;\n    da[2] = _j - (da3 - bvirt) + (_i - bvirt);\n    da[3] = da3;\n    s1 = aex * cey;\n    c = splitter * aex;\n    ahi = c - (c - aex);\n    alo = aex - ahi;\n    c = splitter * cey;\n    bhi = c - (c - cey);\n    blo = cey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = cex * aey;\n    c = splitter * cex;\n    ahi = c - (c - cex);\n    alo = cex - ahi;\n    c = splitter * aey;\n    bhi = c - (c - aey);\n    blo = aey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ac[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ac[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    ac3 = _j + _i;\n    bvirt = ac3 - _j;\n    ac[2] = _j - (ac3 - bvirt) + (_i - bvirt);\n    ac[3] = ac3;\n    s1 = bex * dey;\n    c = splitter * bex;\n    ahi = c - (c - bex);\n    alo = bex - ahi;\n    c = splitter * dey;\n    bhi = c - (c - dey);\n    blo = dey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = dex * bey;\n    c = splitter * dex;\n    ahi = c - (c - dex);\n    alo = dex - ahi;\n    c = splitter * bey;\n    bhi = c - (c - bey);\n    blo = bey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    bd[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    bd[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    bd3 = _j + _i;\n    bvirt = bd3 - _j;\n    bd[2] = _j - (bd3 - bvirt) + (_i - bvirt);\n    bd[3] = bd3;\n\n    const finlen = sum(\n        sum(\n            negate(liftadapt(bc, cd, bd, dez, bez, -cez, aex, aey, aez, adet), adet), adet,\n            liftadapt(cd, da, ac, aez, cez, dez, bex, bey, bez, bdet), bdet, abdet), abdet,\n        sum(\n            negate(liftadapt(da, ab, bd, bez, dez, aez, cex, cey, cez, cdet), cdet), cdet,\n            liftadapt(ab, bc, ac, cez, aez, -bez, dex, dey, dez, ddet), ddet, cddet), cddet, fin);\n\n    let det = estimate(finlen, fin);\n    let errbound = isperrboundB * permanent;\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    bvirt = ax - aex;\n    aextail = ax - (aex + bvirt) + (bvirt - ex);\n    bvirt = ay - aey;\n    aeytail = ay - (aey + bvirt) + (bvirt - ey);\n    bvirt = az - aez;\n    aeztail = az - (aez + bvirt) + (bvirt - ez);\n    bvirt = bx - bex;\n    bextail = bx - (bex + bvirt) + (bvirt - ex);\n    bvirt = by - bey;\n    beytail = by - (bey + bvirt) + (bvirt - ey);\n    bvirt = bz - bez;\n    beztail = bz - (bez + bvirt) + (bvirt - ez);\n    bvirt = cx - cex;\n    cextail = cx - (cex + bvirt) + (bvirt - ex);\n    bvirt = cy - cey;\n    ceytail = cy - (cey + bvirt) + (bvirt - ey);\n    bvirt = cz - cez;\n    ceztail = cz - (cez + bvirt) + (bvirt - ez);\n    bvirt = dx - dex;\n    dextail = dx - (dex + bvirt) + (bvirt - ex);\n    bvirt = dy - dey;\n    deytail = dy - (dey + bvirt) + (bvirt - ey);\n    bvirt = dz - dez;\n    deztail = dz - (dez + bvirt) + (bvirt - ez);\n    if (aextail === 0 && aeytail === 0 && aeztail === 0 &&\n        bextail === 0 && beytail === 0 && beztail === 0 &&\n        cextail === 0 && ceytail === 0 && ceztail === 0 &&\n        dextail === 0 && deytail === 0 && deztail === 0) {\n        return det;\n    }\n\n    errbound = isperrboundC * permanent + resulterrbound * Math.abs(det);\n\n    const abeps = (aex * beytail + bey * aextail) - (aey * bextail + bex * aeytail);\n    const bceps = (bex * ceytail + cey * bextail) - (bey * cextail + cex * beytail);\n    const cdeps = (cex * deytail + dey * cextail) - (cey * dextail + dex * ceytail);\n    const daeps = (dex * aeytail + aey * dextail) - (dey * aextail + aex * deytail);\n    const aceps = (aex * ceytail + cey * aextail) - (aey * cextail + cex * aeytail);\n    const bdeps = (bex * deytail + dey * bextail) - (bey * dextail + dex * beytail);\n    det +=\n        (((bex * bex + bey * bey + bez * bez) * ((cez * daeps + dez * aceps + aez * cdeps) +\n        (ceztail * da3 + deztail * ac3 + aeztail * cd3)) + (dex * dex + dey * dey + dez * dez) *\n        ((aez * bceps - bez * aceps + cez * abeps) + (aeztail * bc3 - beztail * ac3 + ceztail * ab3))) -\n        ((aex * aex + aey * aey + aez * aez) * ((bez * cdeps - cez * bdeps + dez * bceps) +\n        (beztail * cd3 - ceztail * bd3 + deztail * bc3)) + (cex * cex + cey * cey + cez * cez) *\n        ((dez * abeps + aez * bdeps + bez * daeps) + (deztail * ab3 + aeztail * bd3 + beztail * da3)))) +\n        2 * (((bex * bextail + bey * beytail + bez * beztail) * (cez * da3 + dez * ac3 + aez * cd3) +\n        (dex * dextail + dey * deytail + dez * deztail) * (aez * bc3 - bez * ac3 + cez * ab3)) -\n        ((aex * aextail + aey * aeytail + aez * aeztail) * (bez * cd3 - cez * bd3 + dez * bc3) +\n        (cex * cextail + cey * ceytail + cez * ceztail) * (dez * ab3 + aez * bd3 + bez * da3)));\n\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    return insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez);\n}\n\nexport function insphere(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {\n    const aex = ax - ex;\n    const bex = bx - ex;\n    const cex = cx - ex;\n    const dex = dx - ex;\n    const aey = ay - ey;\n    const bey = by - ey;\n    const cey = cy - ey;\n    const dey = dy - ey;\n    const aez = az - ez;\n    const bez = bz - ez;\n    const cez = cz - ez;\n    const dez = dz - ez;\n\n    const aexbey = aex * bey;\n    const bexaey = bex * aey;\n    const ab = aexbey - bexaey;\n    const bexcey = bex * cey;\n    const cexbey = cex * bey;\n    const bc = bexcey - cexbey;\n    const cexdey = cex * dey;\n    const dexcey = dex * cey;\n    const cd = cexdey - dexcey;\n    const dexaey = dex * aey;\n    const aexdey = aex * dey;\n    const da = dexaey - aexdey;\n    const aexcey = aex * cey;\n    const cexaey = cex * aey;\n    const ac = aexcey - cexaey;\n    const bexdey = bex * dey;\n    const dexbey = dex * bey;\n    const bd = bexdey - dexbey;\n\n    const alift = aex * aex + aey * aey + aez * aez;\n    const blift = bex * bex + bey * bey + bez * bez;\n    const clift = cex * cex + cey * cey + cez * cez;\n    const dlift = dex * dex + dey * dey + dez * dez;\n\n    const det =\n        (clift * (dez * ab + aez * bd + bez * da) - dlift * (aez * bc - bez * ac + cez * ab)) +\n        (alift * (bez * cd - cez * bd + dez * bc) - blift * (cez * da + dez * ac + aez * cd));\n\n    const aezplus = Math.abs(aez);\n    const bezplus = Math.abs(bez);\n    const cezplus = Math.abs(cez);\n    const dezplus = Math.abs(dez);\n    const aexbeyplus = Math.abs(aexbey) + Math.abs(bexaey);\n    const bexceyplus = Math.abs(bexcey) + Math.abs(cexbey);\n    const cexdeyplus = Math.abs(cexdey) + Math.abs(dexcey);\n    const dexaeyplus = Math.abs(dexaey) + Math.abs(aexdey);\n    const aexceyplus = Math.abs(aexcey) + Math.abs(cexaey);\n    const bexdeyplus = Math.abs(bexdey) + Math.abs(dexbey);\n    const permanent =\n        (cexdeyplus * bezplus + bexdeyplus * cezplus + bexceyplus * dezplus) * alift +\n        (dexaeyplus * cezplus + aexceyplus * dezplus + cexdeyplus * aezplus) * blift +\n        (aexbeyplus * dezplus + bexdeyplus * aezplus + dexaeyplus * bezplus) * clift +\n        (bexceyplus * aezplus + aexceyplus * bezplus + aexbeyplus * cezplus) * dlift;\n\n    const errbound = isperrboundA * permanent;\n    if (det > errbound || -det > errbound) {\n        return det;\n    }\n    return -insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez, permanent);\n}\n\nexport function inspherefast(pax, pay, paz, pbx, pby, pbz, pcx, pcy, pcz, pdx, pdy, pdz, pex, pey, pez) {\n    const aex = pax - pex;\n    const bex = pbx - pex;\n    const cex = pcx - pex;\n    const dex = pdx - pex;\n    const aey = pay - pey;\n    const bey = pby - pey;\n    const cey = pcy - pey;\n    const dey = pdy - pey;\n    const aez = paz - pez;\n    const bez = pbz - pez;\n    const cez = pcz - pez;\n    const dez = pdz - pez;\n\n    const ab = aex * bey - bex * aey;\n    const bc = bex * cey - cex * bey;\n    const cd = cex * dey - dex * cey;\n    const da = dex * aey - aex * dey;\n    const ac = aex * cey - cex * aey;\n    const bd = bex * dey - dex * bey;\n\n    const abc = aez * bc - bez * ac + cez * ab;\n    const bcd = bez * cd - cez * bd + dez * bc;\n    const cda = cez * da + dez * ac + aez * cd;\n    const dab = dez * ab + aez * bd + bez * da;\n\n    const alift = aex * aex + aey * aey + aez * aez;\n    const blift = bex * bex + bey * bey + bez * bez;\n    const clift = cex * cex + cey * cey + cez * cez;\n    const dlift = dex * dex + dey * dey + dez * dez;\n\n    return (clift * dab - dlift * abc) + (alift * bcd - blift * cda);\n}\n"],"names":["greatest","values","compare","max","defined","length","maxValue","element","value","array","empty","arrayify","Array","from","cross","reduce","reducer","pop","lengths","map","j","index","fill","product","some","push","i","cumsum","valueof","sum","Float64Array","undefined","v","variance","delta","count","mean","deviation","Math","sqrt","identity","x","group","keys","nest","groups","flatten","n","flatMap","g","key","flatGroup","flatRollup","rollups","rollup","unique","indexes","Error","regroup","keyof","get","set","groupSort","sort","ak","av","bk","bv","ascending","prototype","slice","constant","bin","domain","extent","threshold","sturges","histogram","data","isArray","step","xz","x0","x1","tz","tn","nice","ticks","isFinite","floor","ceil","m","a","b","bins","min","bisect","_","arguments","thresholds","call","thresholdFreedmanDiaconis","c","d","quantile","pow","thresholdScott","cbrt","median","medianIndex","mode","counts","modeValue","modeCount","pairs","pairof","pair","previous","first","rank","Symbol","iterator","TypeError","V","R","compareIndex","k","r","Uint32Array","forEach","NaN","least","minValue","leastIndex","minIndex","greatestIndex","maxIndex","scan","shuffler","random","i0","i1","t","transpose","matrix","row","zip","every","test","filter","mapper","done","next","reverse","difference","others","other","delete","disjoint","has","Object","is","add","intersection","out","superset","Set","o","io","intern","ivalue","valueOf","subset","union","merge","arrays","permute","source","p","isNaN","value0","subarray","quantileSorted","quantileIndex","numbers","quickselect","left","right","Infinity","z","log","s","exp","sd","swap","F","f","ascendingDefined","compareDefined","A","B","C","D","E","ED","EB","BC_DA","cubehelix","h","l","opacity","Cubehelix","bl","atan2","cubehelixConvert","this","brighter","darker","rgb","cosh","cos","sinh","sin","Xn","Yn","Zn","t0","t1","t2","t3","labConvert","Lab","Hcl","hcl2lab","rgb2lrgb","y","xyz2lab","gray","lab","lab2xyz","lrgb2rgb","hclConvert","lch","hcl","radians","PI","degrees","defaultSeparation","parent","meanXReduce","maxYReduce","separation","dx","dy","nodeSize","cluster","root","previousNode","eachAfter","node","children","meanX","maxY","leafLeft","leafRight","size","preroot","depth","ambiguous","imputed","defaultId","id","defaultParentId","parentId","path","stratify","nodeId","nodeKey","nodes","currentId","currentParentId","nodeByKey","Map","I","slash","normalize","P","parentof","S","eachBefore","nextLeft","nextRight","moveSubtree","wm","wp","shift","change","nextAncestor","vim","ancestor","TreeNode","tree","child","treeRoot","firstWalk","secondWalk","sizeNode","bottom","tx","kx","ky","siblings","w","executeShifts","midpoint","vip","vop","vom","sip","sop","sim","som","apportion","create","hue","cubehelixGamma","start","end","gamma","cubehelixLong","range","hsl","color","hslLong","hclLong","interpolator","samples","piecewise","interpolate","unknown","scale","invert","number","copy","linear","transformSymlog","sign","log1p","abs","transformSymexp","expm1","symlogish","transform","symlog","init","apply","square","radial","squared","continuous","round","unsquare","rangeRound","clamp","rescale","invertExtent","indexOf","quantiles","quantize","transformer","k10","r0","r1","target","sequential","sequentialLog","base","sequentialSymlog","sequentialPow","exponent","sequentialSqrt","sequentialQuantile","k21","x2","r2","diverging","divergingLog","divergingSymlog","divergingPow","divergingSqrt","name","creator","document","documentElement","nextId","local","Local","toString","constructor","parentNode","remove","events","sourceEvent","currentTarget","touches","event","pointer","selector","querySelectorAll","epsilon","elen","e","flen","Q","Qnew","hh","bvirt","enow","fnow","eindex","findex","hindex","vec","ccwerrboundA","ccwerrboundB","ccwerrboundC","C1","C2","u","orient2d","ax","ay","bx","by","cx","cy","detleft","detright","det","detsum","acxtail","acytail","bcxtail","bcytail","ahi","alo","bhi","blo","_i","_j","_0","s1","s0","u3","acx","bcx","acy","bcy","errbound","C1len","C2len","Dlen","orient2dadapt"],"sourceRoot":""}