claude-yes 1.10.0

package/dist/index.js

@@ -0,0 +1,4949 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// node_modules/unwind-array/src/index.js
+var require_src = __commonJS((exports, module) => {
+  var unwind = (dataObject, options) => {
+    const unwindRecursive = (dataObject2, path2, currPath) => {
+      const pathArr = path2.split(".");
+      if (!currPath) {
+        currPath = pathArr[0];
+      }
+      const result = [];
+      let added = false;
+      const addObject = (objectTempUnwind, objectKey) => {
+        Object.keys(objectTempUnwind).forEach((objectTempUnwindKey) => {
+          const newObjectCopy = {};
+          Object.keys(dataObject2).forEach((dataObjectKey) => {
+            newObjectCopy[dataObjectKey] = dataObject2[dataObjectKey];
+          });
+          newObjectCopy[objectKey] = objectTempUnwind[objectTempUnwindKey];
+          added = true;
+          result.push(newObjectCopy);
+        });
+      };
+      Object.keys(dataObject2).forEach((objectKey) => {
+        if (currPath === objectKey) {
+          if (dataObject2[objectKey] instanceof Array) {
+            if (dataObject2[objectKey].length === 0 && options.preserveEmptyArray !== true) {
+              delete dataObject2[objectKey];
+            } else {
+              Object.keys(dataObject2[objectKey]).forEach((objectElementKey) => {
+                addObject(unwindRecursive(dataObject2[objectKey][objectElementKey], path2.replace(`${currPath}.`, "")), objectKey);
+              });
+            }
+          } else {
+            addObject(unwindRecursive(dataObject2[objectKey], path2.replace(`${currPath}.`, "")), objectKey);
+          }
+        }
+      });
+      if (!added) {
+        result.push(dataObject2);
+      }
+      return result;
+    };
+    return unwindRecursive(dataObject, options.path);
+  };
+  module.exports = { unwind };
+});
+
+// node_modules/phpdie/dist/index.js
+var phpdie_default = DIE;
+function DIE(reason, ...slots) {
+  throw errorFormat(reason, ...slots);
+}
+function errorFormat(reason, ...slots) {
+  if (typeof reason === "string") {
+    return reason.trim();
+  }
+  if (Array.isArray(reason)) {
+    return reason.map((e, i) => e + (slots[i] ?? "")).join("");
+  }
+  return reason;
+}
+
+// node_modules/polyfill-text-encoder-stream/dist/index.js
+class PolyfillTextEncoderStream {
+  _encoder = new TextEncoder;
+  _reader = null;
+  ready = Promise.resolve();
+  closed = false;
+  readable = new ReadableStream({
+    start: (controller) => {
+      this._reader = controller;
+    }
+  });
+  writable = new WritableStream({
+    write: async (chunk) => {
+      if (typeof chunk !== "string") {
+        this._reader.enqueue(chunk);
+        return;
+      }
+      if (chunk != null && this._reader) {
+        const encoded = this._encoder.encode(chunk);
+        this._reader.enqueue(encoded);
+      }
+    },
+    close: () => {
+      this._reader?.close();
+      this.closed = true;
+    },
+    abort: (reason) => {
+      this._reader?.error(reason);
+      this.closed = true;
+    }
+  });
+}
+
+// node_modules/rambda/dist/rambda.js
+var cloneList = (list) => Array.prototype.slice.call(list);
+function curry(fn, args = []) {
+  return (..._args) => ((rest) => rest.length >= fn.length ? fn(...rest) : curry(fn, rest))([...args, ..._args]);
+}
+function adjustFn(index, replaceFn, list) {
+  const actualIndex = index < 0 ? list.length + index : index;
+  if (index >= list.length || actualIndex < 0)
+    return list;
+  const clone = cloneList(list);
+  clone[actualIndex] = replaceFn(clone[actualIndex]);
+  return clone;
+}
+var adjust = curry(adjustFn);
+function always(x) {
+  return (_) => x;
+}
+var {
+  isArray
+} = Array;
+function assocFn(prop, newValue, obj) {
+  return Object.assign({}, obj, {
+    [prop]: newValue
+  });
+}
+var assoc = curry(assocFn);
+function _isInteger(n) {
+  return n << 0 === n;
+}
+var isInteger = Number.isInteger || _isInteger;
+var isIndexInteger = (index) => Number.isInteger(Number(index));
+function createPath(path, delimiter = ".") {
+  return typeof path === "string" ? path.split(delimiter).map((x) => isInteger(x) ? Number(x) : x) : path;
+}
+function assocPathFn(path, newValue, input) {
+  const pathArrValue = createPath(path);
+  if (pathArrValue.length === 0)
+    return newValue;
+  const index = pathArrValue[0];
+  if (pathArrValue.length > 1) {
+    const condition = typeof input !== "object" || input === null || !input.hasOwnProperty(index);
+    const nextInput = condition ? isIndexInteger(pathArrValue[1]) ? [] : {} : input[index];
+    newValue = assocPathFn(Array.prototype.slice.call(pathArrValue, 1), newValue, nextInput);
+  }
+  if (isIndexInteger(index) && isArray(input)) {
+    const arr = cloneList(input);
+    arr[index] = newValue;
+    return arr;
+  }
+  return assocFn(index, newValue, input);
+}
+var assocPath = curry(assocPathFn);
+function clampFn(min, max, input) {
+  if (min > max) {
+    throw new Error("min must not be greater than max in clamp(min, max, value)");
+  }
+  if (input >= min && input <= max)
+    return input;
+  if (input > max)
+    return max;
+  if (input < min)
+    return min;
+}
+var clamp = curry(clampFn);
+function clone(input) {
+  const out = isArray(input) ? Array(input.length) : {};
+  if (input && input.getTime)
+    return new Date(input.getTime());
+  for (const key in input) {
+    const v = input[key];
+    out[key] = typeof v === "object" && v !== null ? v.getTime ? new Date(v.getTime()) : clone(v) : v;
+  }
+  return out;
+}
+
+class ReduceStopper {
+  constructor(value) {
+    this.value = value;
+  }
+}
+function reduceFn(reducer, acc, list) {
+  if (list == null) {
+    return acc;
+  }
+  if (!isArray(list)) {
+    throw new TypeError("reduce: list must be array or iterable");
+  }
+  let index = 0;
+  const len = list.length;
+  while (index < len) {
+    acc = reducer(acc, list[index], index, list);
+    if (acc instanceof ReduceStopper) {
+      return acc.value;
+    }
+    index++;
+  }
+  return acc;
+}
+var reduce = curry(reduceFn);
+function isFalsy(input) {
+  return input === undefined || input === null || Number.isNaN(input) === true;
+}
+function defaultTo(defaultArgument, input) {
+  if (arguments.length === 1) {
+    return (_input) => defaultTo(defaultArgument, _input);
+  }
+  return isFalsy(input) ? defaultArgument : input;
+}
+function type(input) {
+  if (input === null) {
+    return "Null";
+  } else if (input === undefined) {
+    return "Undefined";
+  } else if (Number.isNaN(input)) {
+    return "NaN";
+  }
+  const typeResult = Object.prototype.toString.call(input).slice(8, -1);
+  return typeResult === "AsyncFunction" ? "Promise" : typeResult;
+}
+function _indexOf(valueToFind, list) {
+  if (!isArray(list))
+    throw new Error(`Cannot read property 'indexOf' of ${list}`);
+  const typeOfValue = type(valueToFind);
+  if (!["Array", "NaN", "Object", "RegExp"].includes(typeOfValue))
+    return list.indexOf(valueToFind);
+  let index = -1;
+  let foundIndex = -1;
+  const {
+    length
+  } = list;
+  while (++index < length && foundIndex === -1)
+    if (equals(list[index], valueToFind))
+      foundIndex = index;
+  return foundIndex;
+}
+function _arrayFromIterator(iter) {
+  const list = [];
+  let next;
+  while (!(next = iter.next()).done)
+    list.push(next.value);
+  return list;
+}
+function _compareSets(a, b) {
+  if (a.size !== b.size)
+    return false;
+  const aList = _arrayFromIterator(a.values());
+  const bList = _arrayFromIterator(b.values());
+  const filtered = aList.filter((aInstance) => _indexOf(aInstance, bList) === -1);
+  return filtered.length === 0;
+}
+function compareErrors(a, b) {
+  if (a.message !== b.message)
+    return false;
+  if (a.toString !== b.toString)
+    return false;
+  return a.toString() === b.toString();
+}
+function parseDate(maybeDate) {
+  if (!maybeDate.toDateString)
+    return [false];
+  return [true, maybeDate.getTime()];
+}
+function parseRegex(maybeRegex) {
+  if (maybeRegex.constructor !== RegExp)
+    return [false];
+  return [true, maybeRegex.toString()];
+}
+function equals(a, b) {
+  if (arguments.length === 1)
+    return (_b) => equals(a, _b);
+  if (Object.is(a, b))
+    return true;
+  const aType = type(a);
+  if (aType !== type(b))
+    return false;
+  if (aType === "Function")
+    return a.name === undefined ? false : a.name === b.name;
+  if (["NaN", "Null", "Undefined"].includes(aType))
+    return true;
+  if (["BigInt", "Number"].includes(aType)) {
+    if (Object.is(-0, a) !== Object.is(-0, b))
+      return false;
+    return a.toString() === b.toString();
+  }
+  if (["Boolean", "String"].includes(aType))
+    return a.toString() === b.toString();
+  if (aType === "Array") {
+    const aClone = Array.from(a);
+    const bClone = Array.from(b);
+    if (aClone.toString() !== bClone.toString())
+      return false;
+    let loopArrayFlag = true;
+    aClone.forEach((aCloneInstance, aCloneIndex) => {
+      if (loopArrayFlag) {
+        if (aCloneInstance !== bClone[aCloneIndex] && !equals(aCloneInstance, bClone[aCloneIndex]))
+          loopArrayFlag = false;
+      }
+    });
+    return loopArrayFlag;
+  }
+  const aRegex = parseRegex(a);
+  const bRegex = parseRegex(b);
+  if (aRegex[0])
+    return bRegex[0] ? aRegex[1] === bRegex[1] : false;
+  else if (bRegex[0])
+    return false;
+  const aDate = parseDate(a);
+  const bDate = parseDate(b);
+  if (aDate[0])
+    return bDate[0] ? aDate[1] === bDate[1] : false;
+  else if (bDate[0])
+    return false;
+  if (a instanceof Error) {
+    if (!(b instanceof Error))
+      return false;
+    return compareErrors(a, b);
+  }
+  if (aType === "Set")
+    return _compareSets(a, b);
+  if (aType === "Object") {
+    const aKeys = Object.keys(a);
+    if (aKeys.length !== Object.keys(b).length)
+      return false;
+    let loopObjectFlag = true;
+    aKeys.forEach((aKeyInstance) => {
+      if (loopObjectFlag) {
+        const aValue = a[aKeyInstance];
+        const bValue = b[aKeyInstance];
+        if (aValue !== bValue && !equals(aValue, bValue))
+          loopObjectFlag = false;
+      }
+    });
+    return loopObjectFlag;
+  }
+  return false;
+}
+function differenceWithFn(fn, a, b) {
+  const willReturn = [];
+  const [first, second] = a.length >= b.length ? [a, b] : [b, a];
+  first.forEach((item) => {
+    const hasItem = second.some((secondItem) => fn(item, secondItem));
+    if (!hasItem && _indexOf(item, willReturn) === -1) {
+      willReturn.push(item);
+    }
+  });
+  return willReturn;
+}
+var differenceWith = curry(differenceWithFn);
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1;r < arguments.length; r++) {
+    var t = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function _toPrimitive(t, r) {
+  if (typeof t != "object" || !t)
+    return t;
+  var e = t[Symbol.toPrimitive];
+  if (e !== undefined) {
+    var i = e.call(t, r || "default");
+    if (typeof i != "object")
+      return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (r === "string" ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return typeof i == "symbol" ? i : i + "";
+}
+function pathFn(pathInput, obj) {
+  let willReturn = obj;
+  let counter = 0;
+  const pathArrValue = createPath(pathInput);
+  while (counter < pathArrValue.length) {
+    if (willReturn === null || willReturn === undefined) {
+      return;
+    }
+    if (willReturn[pathArrValue[counter]] === null)
+      return;
+    willReturn = willReturn[pathArrValue[counter]];
+    counter++;
+  }
+  return willReturn;
+}
+function path(pathInput, obj) {
+  if (arguments.length === 1)
+    return (_obj) => path(pathInput, _obj);
+  if (obj === null || obj === undefined) {
+    return;
+  }
+  return pathFn(pathInput, obj);
+}
+function updateFn(index, newValue, list) {
+  const clone2 = cloneList(list);
+  if (index === -1)
+    return clone2.fill(newValue, index);
+  return clone2.fill(newValue, index, index + 1);
+}
+var update = curry(updateFn);
+function eqByFn(fn, a, b) {
+  return equals(fn(a), fn(b));
+}
+var eqBy = curry(eqByFn);
+function propFn(searchProperty, obj) {
+  if (!obj)
+    return;
+  return obj[searchProperty];
+}
+function prop(searchProperty, obj) {
+  if (arguments.length === 1)
+    return (_obj) => prop(searchProperty, _obj);
+  return propFn(searchProperty, obj);
+}
+function eqPropsFn(property, objA, objB) {
+  return equals(prop(property, objA), prop(property, objB));
+}
+var eqProps = curry(eqPropsFn);
+function has(prop2, obj) {
+  if (arguments.length === 1)
+    return (_obj) => has(prop2, _obj);
+  if (!obj)
+    return false;
+  return obj.hasOwnProperty(prop2);
+}
+function ifElseFn(condition, onTrue, onFalse) {
+  return (...input) => {
+    const conditionResult = typeof condition === "boolean" ? condition : condition(...input);
+    if (Boolean(conditionResult)) {
+      return onTrue(...input);
+    }
+    return onFalse(...input);
+  };
+}
+var ifElse = curry(ifElseFn);
+function baseSlice(array, start, end) {
+  let index = -1;
+  let {
+    length
+  } = array;
+  end = end > length ? length : end;
+  if (end < 0) {
+    end += length;
+  }
+  length = start > end ? 0 : end - start >>> 0;
+  start >>>= 0;
+  const result = Array(length);
+  while (++index < length) {
+    result[index] = array[index + start];
+  }
+  return result;
+}
+function _includesWith(pred, x, list) {
+  let idx = 0;
+  const len = list.length;
+  while (idx < len) {
+    if (pred(x, list[idx]))
+      return true;
+    idx += 1;
+  }
+  return false;
+}
+function _filter(fn, list) {
+  let idx = 0;
+  const len = list.length;
+  const result = [];
+  while (idx < len) {
+    if (fn(list[idx]))
+      result[result.length] = list[idx];
+    idx += 1;
+  }
+  return result;
+}
+function innerJoinFn(pred, xs, ys) {
+  return _filter((x) => _includesWith(pred, x, ys), xs);
+}
+var innerJoin = curry(innerJoinFn);
+function insertFn(indexToInsert, valueToInsert, array) {
+  return [...array.slice(0, indexToInsert), valueToInsert, ...array.slice(indexToInsert)];
+}
+var insert = curry(insertFn);
+function insertAllFn(index, listToInsert, list) {
+  return [...list.slice(0, index), ...listToInsert, ...list.slice(index)];
+}
+var insertAll = curry(insertAllFn);
+function is(targetPrototype, x) {
+  if (arguments.length === 1)
+    return (_x) => is(targetPrototype, _x);
+  return x != null && x.constructor === targetPrototype || x instanceof targetPrototype;
+}
+function maxByFn(compareFn, x, y) {
+  return compareFn(y) > compareFn(x) ? y : x;
+}
+var maxBy = curry(maxByFn);
+function mergeWithFn(mergeFn, aInput, bInput) {
+  const a = aInput !== null && aInput !== undefined ? aInput : {};
+  const b = bInput !== null && bInput !== undefined ? bInput : {};
+  const willReturn = {};
+  Object.keys(a).forEach((key) => {
+    if (b[key] === undefined)
+      willReturn[key] = a[key];
+    else
+      willReturn[key] = mergeFn(a[key], b[key]);
+  });
+  Object.keys(b).forEach((key) => {
+    if (willReturn[key] !== undefined)
+      return;
+    if (a[key] === undefined)
+      willReturn[key] = b[key];
+    else
+      willReturn[key] = mergeFn(a[key], b[key]);
+  });
+  return willReturn;
+}
+var mergeWith = curry(mergeWithFn);
+function minByFn(compareFn, x, y) {
+  return compareFn(y) < compareFn(x) ? y : x;
+}
+var minBy = curry(minByFn);
+function isIterable(input) {
+  return Array.isArray(input) || type(input) === "Object";
+}
+function modifyFn(property, fn, iterable) {
+  if (!isIterable(iterable))
+    return iterable;
+  if (iterable[property] === undefined)
+    return iterable;
+  if (isArray(iterable)) {
+    return updateFn(property, fn(iterable[property]), iterable);
+  }
+  return _objectSpread2(_objectSpread2({}, iterable), {}, {
+    [property]: fn(iterable[property])
+  });
+}
+var modify = curry(modifyFn);
+function modifyPathFn(pathInput, fn, object) {
+  const path$1 = createPath(pathInput);
+  if (path$1.length === 1) {
+    return _objectSpread2(_objectSpread2({}, object), {}, {
+      [path$1[0]]: fn(object[path$1[0]])
+    });
+  }
+  if (path(path$1, object) === undefined)
+    return object;
+  const val = modifyPath(Array.prototype.slice.call(path$1, 1), fn, object[path$1[0]]);
+  if (val === object[path$1[0]]) {
+    return object;
+  }
+  return assoc(path$1[0], val, object);
+}
+var modifyPath = curry(modifyPathFn);
+function moveFn(fromIndex, toIndex, list) {
+  if (fromIndex < 0 || toIndex < 0) {
+    throw new Error("Rambda.move does not support negative indexes");
+  }
+  if (fromIndex > list.length - 1 || toIndex > list.length - 1)
+    return list;
+  const clone2 = cloneList(list);
+  clone2[fromIndex] = list[toIndex];
+  clone2[toIndex] = list[fromIndex];
+  return clone2;
+}
+var move = curry(moveFn);
+function multiply(x, y) {
+  if (arguments.length === 1)
+    return (_y) => multiply(x, _y);
+  return x * y;
+}
+var Identity = (x) => ({
+  x,
+  map: (fn) => Identity(fn(x))
+});
+function overFn(lens, fn, object) {
+  return lens((x) => Identity(fn(x)))(object).x;
+}
+var over = curry(overFn);
+function pathEqFn(pathToSearch, target, input) {
+  return equals(path(pathToSearch, input), target);
+}
+var pathEq = curry(pathEqFn);
+function pathOrFn(defaultValue, pathInput, obj) {
+  return defaultTo(defaultValue, path(pathInput, obj));
+}
+var pathOr = curry(pathOrFn);
+function pathSatisfiesFn(fn, pathInput, obj) {
+  if (pathInput.length === 0)
+    throw new Error("R.pathSatisfies received an empty path");
+  return Boolean(fn(path(pathInput, obj)));
+}
+var pathSatisfies = curry(pathSatisfiesFn);
+var product = reduce(multiply, 1);
+function propEqFn(valueToMatch, propToFind, obj) {
+  if (!obj)
+    return false;
+  return equals(valueToMatch, prop(propToFind, obj));
+}
+var propEq = curry(propEqFn);
+function propIsFn(targetPrototype, property, obj) {
+  return is(targetPrototype, obj[property]);
+}
+var propIs = curry(propIsFn);
+function propOrFn(defaultValue, property, obj) {
+  if (!obj)
+    return defaultValue;
+  return defaultTo(defaultValue, obj[property]);
+}
+var propOr = curry(propOrFn);
+function propSatisfiesFn(predicate, property, obj) {
+  return predicate(prop(property, obj));
+}
+var propSatisfies = curry(propSatisfiesFn);
+function reduceByFunction(valueFn, valueAcc, keyFn, acc, elt) {
+  const key = keyFn(elt);
+  const value = valueFn(has(key, acc) ? acc[key] : clone(valueAcc), elt);
+  acc[key] = value;
+  return acc;
+}
+function reduceByFn(valueFn, valueAcc, keyFn, list) {
+  return reduce((acc, elt) => reduceByFunction(valueFn, valueAcc, keyFn, acc, elt), {}, list);
+}
+var reduceBy = curry(reduceByFn);
+function replaceFn(pattern, replacer, str) {
+  return str.replace(pattern, replacer);
+}
+var replace = curry(replaceFn);
+function setFn(lens, replacer, x) {
+  return over(lens, always(replacer), x);
+}
+var set = curry(setFn);
+function sliceFn(from, to, list) {
+  return list.slice(from, to);
+}
+var slice = curry(sliceFn);
+function sortBy(sortFn, list) {
+  if (arguments.length === 1)
+    return (_list) => sortBy(sortFn, _list);
+  const clone2 = cloneList(list);
+  return clone2.sort((a, b) => {
+    const aSortResult = sortFn(a);
+    const bSortResult = sortFn(b);
+    if (aSortResult === bSortResult)
+      return 0;
+    return aSortResult < bSortResult ? -1 : 1;
+  });
+}
+function take(howMany, listOrString) {
+  if (arguments.length === 1)
+    return (_listOrString) => take(howMany, _listOrString);
+  if (howMany < 0)
+    return listOrString.slice();
+  if (typeof listOrString === "string")
+    return listOrString.slice(0, howMany);
+  return baseSlice(listOrString, 0, howMany);
+}
+function swapArrayOrString(indexA, indexB, iterable) {
+  const actualIndexA = indexA < 0 ? iterable.length + indexA : indexA;
+  const actualIndexB = indexB < 0 ? iterable.length + indexB : indexB;
+  if (actualIndexA === actualIndexB || Math.min(actualIndexA, actualIndexB) < 0 || Math.max(actualIndexA, actualIndexB) >= iterable.length)
+    return iterable;
+  if (typeof iterable === "string") {
+    return iterable.slice(0, actualIndexA) + iterable[actualIndexB] + iterable.slice(actualIndexA + 1, actualIndexB) + iterable[actualIndexA] + iterable.slice(actualIndexB + 1);
+  }
+  const clone2 = iterable.slice();
+  const temp = clone2[actualIndexA];
+  clone2[actualIndexA] = clone2[actualIndexB];
+  clone2[actualIndexB] = temp;
+  return clone2;
+}
+function swapFn(indexA, indexB, iterable) {
+  if (isArray(iterable) || typeof iterable === "string")
+    return swapArrayOrString(indexA, indexB, iterable);
+  const aVal = iterable[indexA];
+  const bVal = iterable[indexB];
+  if (aVal === undefined || bVal === undefined)
+    return iterable;
+  return _objectSpread2(_objectSpread2({}, iterable), {}, {
+    [indexA]: iterable[indexB],
+    [indexB]: iterable[indexA]
+  });
+}
+var swap = curry(swapFn);
+function unlessFn(predicate, whenFalseFn, input) {
+  if (predicate(input))
+    return input;
+  return whenFalseFn(input);
+}
+var unless = curry(unlessFn);
+function whenFn(predicate, whenTrueFn, input) {
+  if (!predicate(input))
+    return input;
+  return whenTrueFn(input);
+}
+var when = curry(whenFn);
+function zipWithFn(fn, x, y) {
+  return take(x.length > y.length ? y.length : x.length, x).map((xInstance, i) => fn(xInstance, y[i]));
+}
+var zipWith = curry(zipWithFn);
+var $equals = equals;
+var $sortBy = sortBy;
+// node_modules/web-streams-extensions/dist/esm/operators/map.js
+function map(select) {
+  let reader = null;
+  async function flush(controller) {
+    try {
+      while (controller.desiredSize > 0 && reader != null) {
+        let next = await reader.read();
+        if (next.done) {
+          controller.close();
+          reader = null;
+        } else {
+          let mapped = await select(next.value);
+          if (mapped !== undefined)
+            controller.enqueue(mapped);
+        }
+      }
+    } catch (err) {
+      controller.error(err);
+    }
+  }
+  return function(src, opts) {
+    return new ReadableStream({
+      start(controller) {
+        reader = src.getReader();
+        return flush(controller);
+      },
+      pull(controller) {
+        return flush(controller);
+      },
+      cancel(reason) {
+        if (reader) {
+          reader.cancel(reason);
+          reader.releaseLock();
+          reader = null;
+        }
+      }
+    }, opts);
+  };
+}
+// node_modules/web-streams-extensions/dist/esm/_readable-like.js
+function isReadableLike(obj) {
+  return obj["readable"] != null;
+}
+
+// node_modules/web-streams-extensions/dist/esm/from.js
+function from(src) {
+  let it;
+  async function flush(controller) {
+    try {
+      while (controller.desiredSize > 0 && it != null) {
+        let next = await it.next();
+        if (next.done) {
+          it = null;
+          controller.close();
+        } else {
+          controller.enqueue(next.value);
+        }
+      }
+    } catch (err) {
+      controller.error(err);
+    }
+  }
+  if (isReadableLike(src)) {
+    return src.readable;
+  }
+  return new ReadableStream({
+    async start(controller) {
+      let iterable;
+      if (typeof src == "function") {
+        src = src();
+      }
+      if (Symbol.asyncIterator && src[Symbol.asyncIterator])
+        iterable = src[Symbol.asyncIterator].bind(src);
+      else if (src[Symbol.iterator])
+        iterable = src[Symbol.iterator].bind(src);
+      else {
+        let value = await Promise.resolve(src);
+        controller.enqueue(value);
+        controller.close();
+        return;
+      }
+      it = iterable();
+      return flush(controller);
+    },
+    async pull(controller) {
+      return flush(controller);
+    },
+    async cancel(reason) {
+      if (reason && it && it.throw) {
+        it.throw(reason);
+      } else if (it && it.return) {
+        await it.return();
+      }
+      it = null;
+    }
+  });
+}
+
+// node_modules/web-streams-extensions/dist/esm/operators/through.js
+function through(dst) {
+  return function(src) {
+    return src.pipeThrough(dst);
+  };
+}
+
+// node_modules/web-streams-extensions/dist/esm/pipe.js
+function pipe(src, ...ops) {
+  if (isReadableLike(src)) {
+    src = src.readable;
+  }
+  return ops.map((x) => isTransform(x) ? through(x) : x).reduce((p, c) => {
+    return c(p, { highWaterMark: 1 });
+  }, src);
+}
+function isTransform(x) {
+  return x["readable"] != null && x["writable"] != null;
+}
+
+// node_modules/web-streams-extensions/dist/esm/utils/signal.js
+class Gate {
+  _count;
+  _queue = [];
+  constructor(_count) {
+    this._count = _count;
+  }
+  async wait() {
+    if (this._count > 0) {
+      --this._count;
+      return Promise.resolve();
+    }
+    return new Promise((r) => {
+      let cb = () => {
+        this._queue.splice(this._queue.indexOf(cb), 1);
+        --this._count;
+        r();
+      };
+      this._queue.push(cb);
+    });
+  }
+  increment() {
+    ++this._count;
+    this.clearQueue();
+  }
+  setCount(count) {
+    this._count = count;
+    this.clearQueue();
+  }
+  clearQueue() {
+    while (this._count > 0 && this._queue.length > 0) {
+      this._queue.shift()();
+    }
+  }
+}
+
+class BlockingQueue {
+  _pushers = [];
+  _pullers = [];
+  constructor() {}
+  async push(value) {
+    return new Promise((r) => {
+      this._pushers.unshift(() => {
+        r();
+        return value;
+      });
+      this.dequeue();
+    });
+  }
+  async pull() {
+    return new Promise((r) => {
+      this._pullers.unshift((value) => {
+        r(value);
+      });
+      this.dequeue();
+    });
+  }
+  dequeue() {
+    while (this._pullers.length > 0 && this._pushers.length > 0) {
+      let puller = this._pullers.pop();
+      let pusher = this._pushers.pop();
+      puller(pusher());
+    }
+  }
+}
+
+// node_modules/web-streams-extensions/dist/esm/operators/schedule.js
+function schedule(scheduler) {
+  let reader = null;
+  async function flush(controller) {
+    try {
+      while (controller.desiredSize > 0 && reader != null) {
+        let next = await reader.read();
+        if (next.done) {
+          controller.close();
+          reader = null;
+        } else {
+          await scheduler.nextTick();
+          controller.enqueue(next.value);
+        }
+      }
+    } catch (err) {
+      controller.error(err);
+    }
+  }
+  return function(src, opts) {
+    return new ReadableStream({
+      start(controller) {
+        reader = src.getReader();
+        return flush(controller);
+      },
+      pull(controller) {
+        return flush(controller);
+      },
+      cancel(reason) {
+        if (reader) {
+          reader.cancel(reason);
+          reader.releaseLock();
+          reader = null;
+        }
+      }
+    }, opts);
+  };
+}
+
+// node_modules/web-streams-extensions/dist/esm/operators/on.js
+function on(callbacks) {
+  let reader = null;
+  async function flush(controller) {
+    try {
+      while (controller.desiredSize > 0 && reader != null) {
+        let next = await reader.read();
+        if (next.done) {
+          controller.close();
+          reader = null;
+          if (callbacks.complete)
+            callbacks.complete();
+        } else {
+          controller.enqueue(next.value);
+        }
+      }
+    } catch (err) {
+      controller.error(err);
+      if (callbacks.error)
+        callbacks.error(err);
+    }
+  }
+  return function(src, opts) {
+    return new ReadableStream({
+      start(controller) {
+        reader = src.getReader();
+        if (callbacks.start)
+          callbacks.start();
+        return flush(controller);
+      },
+      pull(controller) {
+        return flush(controller);
+      },
+      cancel(reason) {
+        if (reader) {
+          reader.cancel(reason);
+          reader.releaseLock();
+          reader = null;
+          if (callbacks.complete)
+            callbacks.complete(reason);
+        }
+      }
+    }, opts);
+  };
+}
+
+// node_modules/web-streams-extensions/dist/esm/to-promise.js
+async function toPromise(src) {
+  let res = undefined;
+  if (isReadableLike(src)) {
+    src = src.readable;
+  }
+  let reader = src.getReader();
+  let done = false;
+  while (done == false) {
+    let next = await reader.read();
+    done = next.done;
+    if (!done)
+      res = next.value;
+  }
+  return res;
+}
+
+// node_modules/web-streams-extensions/dist/esm/operators/merge.js
+function merge(concurrent = Infinity) {
+  if (concurrent == 0)
+    throw Error("zero is an invalid concurrency limit");
+  return function(src) {
+    let outerGate = new Gate(concurrent);
+    let innerQueue = new BlockingQueue;
+    let subscription;
+    let errored = null;
+    return new ReadableStream({
+      start(outerController) {
+        let reading = [];
+        let readingDone = false;
+        toPromise(pipe(src, schedule({
+          nextTick: async () => {
+            await outerGate.wait();
+          }
+        }), map((innerStream) => {
+          if (!(innerStream instanceof ReadableStream)) {
+            innerStream = from(innerStream);
+          }
+          reading.push(innerStream);
+          pipe(innerStream, map(async (value) => {
+            await innerQueue.push({ done: false, value });
+          }), on({
+            error(err) {
+              outerController.error(err);
+            },
+            complete() {
+              outerGate.increment();
+              reading.splice(reading.indexOf(innerStream), 1);
+              if (reading.length == 0 && readingDone) {
+                innerQueue.push({ done: true });
+              }
+            }
+          }));
+        }), on({
+          error(err) {
+            outerController.error(err);
+            errored = err;
+          },
+          complete() {
+            readingDone = true;
+          }
+        }))).catch((err) => {
+          outerController.error(err);
+        });
+      },
+      async pull(controller) {
+        while (controller.desiredSize > 0) {
+          let next = await innerQueue.pull();
+          if (errored) {
+            controller.error(errored);
+          }
+          if (next.done) {
+            controller.close();
+          } else {
+            controller.enqueue(next.value);
+          }
+        }
+      },
+      cancel(reason) {
+        if (subscription) {
+          subscription.unsubscribe();
+          subscription = null;
+        }
+      }
+    });
+  };
+}
+// node_modules/web-streams-extensions/dist/esm/to-array.js
+async function toArray(src) {
+  let res = [];
+  if (isReadableLike(src)) {
+    src = src.readable;
+  }
+  let reader = src.getReader();
+  try {
+    let done = false;
+    while (done == false) {
+      let next = await reader.read();
+      done = next.done;
+      if (!done)
+        res.push(next.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return res;
+}
+// node_modules/web-streams-extensions/dist/esm/_subscribable.js
+class Subscribable {
+  closed = false;
+  subscribers = [];
+  subscribe(cb) {
+    let self = this;
+    self.subscribers.push(cb);
+    let _closed = false;
+    return {
+      get closed() {
+        return _closed || self.closed;
+      },
+      unsubscribe() {
+        let index = self.subscribers.findIndex((x) => x === cb);
+        if (index >= 0) {
+          self.subscribers.splice(index, 1);
+        }
+        _closed = true;
+      }
+    };
+  }
+  next(value) {
+    return Math.min(...this.subscribers.map((x) => x.next(value)));
+  }
+  complete() {
+    for (let sub of this.subscribers) {
+      sub.complete();
+    }
+    this.subscribers = [];
+    this.closed = true;
+  }
+  error(err) {
+    for (let sub of this.subscribers) {
+      sub.error(err);
+    }
+    this.subscribers = [];
+    this.closed = true;
+  }
+}
+
+// node_modules/web-streams-extensions/dist/esm/subject.js
+class Subject {
+  _subscribable = new Subscribable;
+  _closingResolve;
+  _closing = new Promise((r) => this._closingResolve = r);
+  get closed() {
+    return this._subscribable.closed;
+  }
+  get readable() {
+    let self = this;
+    let subscription;
+    let cancelled = false;
+    return new ReadableStream({
+      async start(controller) {
+        subscription = self.subscribe({
+          next: (value) => {
+            if (cancelled)
+              return;
+            controller.enqueue(value);
+            return controller.desiredSize;
+          },
+          complete: () => {
+            controller.close();
+          },
+          error: (err) => {
+            controller.error(err);
+          }
+        });
+      },
+      cancel() {
+        cancelled = true;
+        if (subscription) {
+          subscription.unsubscribe();
+        }
+      }
+    });
+  }
+  get writable() {
+    const queuingStrategy = new CountQueuingStrategy({ highWaterMark: 1 });
+    const self = this;
+    let stream = new WritableStream({
+      write(chunk, controller) {
+        if (self.closed && controller.signal.aborted == false) {
+          controller.error();
+          return;
+        }
+        if (controller.signal.aborted) {
+          self._error(controller.signal.reason);
+          return;
+        }
+        self._next(chunk);
+      },
+      close() {
+        self._complete();
+      },
+      abort(reason) {
+        self._error(reason);
+      }
+    }, queuingStrategy);
+    this._closing.then((_) => {
+      if (stream.locked == false) {
+        stream.close();
+      }
+    });
+    return stream;
+  }
+  subscribe(cb) {
+    let subscription = this._subscribable.subscribe(cb);
+    return subscription;
+  }
+  _next(value) {
+    return this._subscribable.next(value);
+  }
+  _complete() {
+    this._subscribable.complete();
+  }
+  _error(err) {
+    this._subscribable.error(err);
+  }
+  async next(value) {
+    return this._next(value);
+  }
+  async complete() {
+    this._closingResolve(undefined);
+    return this._complete();
+  }
+  async error(err) {
+    this._closingResolve(undefined);
+    return this._error(err);
+  }
+}
+// node_modules/string-replace-async/index.js
+function replaceAsync(string, searchValue, replacer) {
+  try {
+    if (typeof replacer === "function") {
+      var values = [];
+      String.prototype.replace.call(string, searchValue, function() {
+        values.push(replacer.apply(undefined, arguments));
+        return "";
+      });
+      return Promise.all(values).then(function(resolvedValues) {
+        return String.prototype.replace.call(string, searchValue, function() {
+          return resolvedValues.shift();
+        });
+      });
+    } else {
+      return Promise.resolve(String.prototype.replace.call(string, searchValue, replacer));
+    }
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+
+// node_modules/sflow/dist/index.js
+var import_unwind_array = __toESM(require_src(), 1);
+// node_modules/d3-dispatch/src/dispatch.js
+var noop = { value: () => {} };
+function dispatch() {
+  for (var i = 0, n = arguments.length, _ = {}, t;i < n; ++i) {
+    if (!(t = arguments[i] + "") || t in _ || /[\s.]/.test(t))
+      throw new Error("illegal type: " + t);
+    _[t] = [];
+  }
+  return new Dispatch(_);
+}
+function Dispatch(_) {
+  this._ = _;
+}
+function parseTypenames(typenames, types) {
+  return typenames.trim().split(/^|\s+/).map(function(t) {
+    var name = "", i = t.indexOf(".");
+    if (i >= 0)
+      name = t.slice(i + 1), t = t.slice(0, i);
+    if (t && !types.hasOwnProperty(t))
+      throw new Error("unknown type: " + t);
+    return { type: t, name };
+  });
+}
+Dispatch.prototype = dispatch.prototype = {
+  constructor: Dispatch,
+  on: function(typename, callback) {
+    var _ = this._, T = parseTypenames(typename + "", _), t, i = -1, n = T.length;
+    if (arguments.length < 2) {
+      while (++i < n)
+        if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name)))
+          return t;
+      return;
+    }
+    if (callback != null && typeof callback !== "function")
+      throw new Error("invalid callback: " + callback);
+    while (++i < n) {
+      if (t = (typename = T[i]).type)
+        _[t] = set2(_[t], typename.name, callback);
+      else if (callback == null)
+        for (t in _)
+          _[t] = set2(_[t], typename.name, null);
+    }
+    return this;
+  },
+  copy: function() {
+    var copy = {}, _ = this._;
+    for (var t in _)
+      copy[t] = _[t].slice();
+    return new Dispatch(copy);
+  },
+  call: function(type2, that) {
+    if ((n = arguments.length - 2) > 0)
+      for (var args = new Array(n), i = 0, n, t;i < n; ++i)
+        args[i] = arguments[i + 2];
+    if (!this._.hasOwnProperty(type2))
+      throw new Error("unknown type: " + type2);
+    for (t = this._[type2], i = 0, n = t.length;i < n; ++i)
+      t[i].value.apply(that, args);
+  },
+  apply: function(type2, that, args) {
+    if (!this._.hasOwnProperty(type2))
+      throw new Error("unknown type: " + type2);
+    for (var t = this._[type2], i = 0, n = t.length;i < n; ++i)
+      t[i].value.apply(that, args);
+  }
+};
+function get(type2, name) {
+  for (var i = 0, n = type2.length, c;i < n; ++i) {
+    if ((c = type2[i]).name === name) {
+      return c.value;
+    }
+  }
+}
+function set2(type2, name, callback) {
+  for (var i = 0, n = type2.length;i < n; ++i) {
+    if (type2[i].name === name) {
+      type2[i] = noop, type2 = type2.slice(0, i).concat(type2.slice(i + 1));
+      break;
+    }
+  }
+  if (callback != null)
+    type2.push({ name, value: callback });
+  return type2;
+}
+var dispatch_default = dispatch;
+// node_modules/d3-selection/src/namespaces.js
+var xhtml = "http://www.w3.org/1999/xhtml";
+var namespaces_default = {
+  svg: "http://www.w3.org/2000/svg",
+  xhtml,
+  xlink: "http://www.w3.org/1999/xlink",
+  xml: "http://www.w3.org/XML/1998/namespace",
+  xmlns: "http://www.w3.org/2000/xmlns/"
+};
+
+// node_modules/d3-selection/src/namespace.js
+function namespace_default(name) {
+  var prefix = name += "", i = prefix.indexOf(":");
+  if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns")
+    name = name.slice(i + 1);
+  return namespaces_default.hasOwnProperty(prefix) ? { space: namespaces_default[prefix], local: name } : name;
+}
+
+// node_modules/d3-selection/src/creator.js
+function creatorInherit(name) {
+  return function() {
+    var document2 = this.ownerDocument, uri = this.namespaceURI;
+    return uri === xhtml && document2.documentElement.namespaceURI === xhtml ? document2.createElement(name) : document2.createElementNS(uri, name);
+  };
+}
+function creatorFixed(fullname) {
+  return function() {
+    return this.ownerDocument.createElementNS(fullname.space, fullname.local);
+  };
+}
+function creator_default(name) {
+  var fullname = namespace_default(name);
+  return (fullname.local ? creatorFixed : creatorInherit)(fullname);
+}
+
+// node_modules/d3-selection/src/selector.js
+function none() {}
+function selector_default(selector) {
+  return selector == null ? none : function() {
+    return this.querySelector(selector);
+  };
+}
+
+// node_modules/d3-selection/src/selection/select.js
+function select_default(select) {
+  if (typeof select !== "function")
+    select = selector_default(select);
+  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0;j < m; ++j) {
+    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0;i < n; ++i) {
+      if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
+        if ("__data__" in node)
+          subnode.__data__ = node.__data__;
+        subgroup[i] = subnode;
+      }
+    }
+  }
+  return new Selection(subgroups, this._parents);
+}
+
+// node_modules/d3-selection/src/array.js
+function array(x) {
+  return x == null ? [] : Array.isArray(x) ? x : Array.from(x);
+}
+
+// node_modules/d3-selection/src/selectorAll.js
+function empty() {
+  return [];
+}
+function selectorAll_default(selector) {
+  return selector == null ? empty : function() {
+    return this.querySelectorAll(selector);
+  };
+}
+
+// node_modules/d3-selection/src/selection/selectAll.js
+function arrayAll(select) {
+  return function() {
+    return array(select.apply(this, arguments));
+  };
+}
+function selectAll_default(select) {
+  if (typeof select === "function")
+    select = arrayAll(select);
+  else
+    select = selectorAll_default(select);
+  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0;j < m; ++j) {
+    for (var group = groups[j], n = group.length, node, i = 0;i < n; ++i) {
+      if (node = group[i]) {
+        subgroups.push(select.call(node, node.__data__, i, group));
+        parents.push(node);
+      }
+    }
+  }
+  return new Selection(subgroups, parents);
+}
+
+// node_modules/d3-selection/src/matcher.js
+function matcher_default(selector) {
+  return function() {
+    return this.matches(selector);
+  };
+}
+function childMatcher(selector) {
+  return function(node) {
+    return node.matches(selector);
+  };
+}
+
+// node_modules/d3-selection/src/selection/selectChild.js
+var find = Array.prototype.find;
+function childFind(match) {
+  return function() {
+    return find.call(this.children, match);
+  };
+}
+function childFirst() {
+  return this.firstElementChild;
+}
+function selectChild_default(match) {
+  return this.select(match == null ? childFirst : childFind(typeof match === "function" ? match : childMatcher(match)));
+}
+
+// node_modules/d3-selection/src/selection/selectChildren.js
+var filter2 = Array.prototype.filter;
+function children() {
+  return Array.from(this.children);
+}
+function childrenFilter(match) {
+  return function() {
+    return filter2.call(this.children, match);
+  };
+}
+function selectChildren_default(match) {
+  return this.selectAll(match == null ? children : childrenFilter(typeof match === "function" ? match : childMatcher(match)));
+}
+
+// node_modules/d3-selection/src/selection/filter.js
+function filter_default(match) {
+  if (typeof match !== "function")
+    match = matcher_default(match);
+  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0;j < m; ++j) {
+    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0;i < n; ++i) {
+      if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
+        subgroup.push(node);
+      }
+    }
+  }
+  return new Selection(subgroups, this._parents);
+}
+
+// node_modules/d3-selection/src/selection/sparse.js
+function sparse_default(update2) {
+  return new Array(update2.length);
+}
+
+// node_modules/d3-selection/src/selection/enter.js
+function enter_default() {
+  return new Selection(this._enter || this._groups.map(sparse_default), this._parents);
+}
+function EnterNode(parent, datum) {
+  this.ownerDocument = parent.ownerDocument;
+  this.namespaceURI = parent.namespaceURI;
+  this._next = null;
+  this._parent = parent;
+  this.__data__ = datum;
+}
+EnterNode.prototype = {
+  constructor: EnterNode,
+  appendChild: function(child) {
+    return this._parent.insertBefore(child, this._next);
+  },
+  insertBefore: function(child, next) {
+    return this._parent.insertBefore(child, next);
+  },
+  querySelector: function(selector) {
+    return this._parent.querySelector(selector);
+  },
+  querySelectorAll: function(selector) {
+    return this._parent.querySelectorAll(selector);
+  }
+};
+
+// node_modules/d3-selection/src/constant.js
+function constant_default(x) {
+  return function() {
+    return x;
+  };
+}
+
+// node_modules/d3-selection/src/selection/data.js
+function bindIndex(parent, group, enter, update2, exit, data) {
+  var i = 0, node, groupLength = group.length, dataLength = data.length;
+  for (;i < dataLength; ++i) {
+    if (node = group[i]) {
+      node.__data__ = data[i];
+      update2[i] = node;
+    } else {
+      enter[i] = new EnterNode(parent, data[i]);
+    }
+  }
+  for (;i < groupLength; ++i) {
+    if (node = group[i]) {
+      exit[i] = node;
+    }
+  }
+}
+function bindKey(parent, group, enter, update2, exit, data, key) {
+  var i, node, nodeByKeyValue = new Map, groupLength = group.length, dataLength = data.length, keyValues = new Array(groupLength), keyValue;
+  for (i = 0;i < groupLength; ++i) {
+    if (node = group[i]) {
+      keyValues[i] = keyValue = key.call(node, node.__data__, i, group) + "";
+      if (nodeByKeyValue.has(keyValue)) {
+        exit[i] = node;
+      } else {
+        nodeByKeyValue.set(keyValue, node);
+      }
+    }
+  }
+  for (i = 0;i < dataLength; ++i) {
+    keyValue = key.call(parent, data[i], i, data) + "";
+    if (node = nodeByKeyValue.get(keyValue)) {
+      update2[i] = node;
+      node.__data__ = data[i];
+      nodeByKeyValue.delete(keyValue);
+    } else {
+      enter[i] = new EnterNode(parent, data[i]);
+    }
+  }
+  for (i = 0;i < groupLength; ++i) {
+    if ((node = group[i]) && nodeByKeyValue.get(keyValues[i]) === node) {
+      exit[i] = node;
+    }
+  }
+}
+function datum(node) {
+  return node.__data__;
+}
+function data_default(value, key) {
+  if (!arguments.length)
+    return Array.from(this, datum);
+  var bind = key ? bindKey : bindIndex, parents = this._parents, groups = this._groups;
+  if (typeof value !== "function")
+    value = constant_default(value);
+  for (var m = groups.length, update2 = new Array(m), enter = new Array(m), exit = new Array(m), j = 0;j < m; ++j) {
+    var parent = parents[j], group = groups[j], groupLength = group.length, data = arraylike(value.call(parent, parent && parent.__data__, j, parents)), dataLength = data.length, enterGroup = enter[j] = new Array(dataLength), updateGroup = update2[j] = new Array(dataLength), exitGroup = exit[j] = new Array(groupLength);
+    bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);
+    for (var i0 = 0, i1 = 0, previous, next;i0 < dataLength; ++i0) {
+      if (previous = enterGroup[i0]) {
+        if (i0 >= i1)
+          i1 = i0 + 1;
+        while (!(next = updateGroup[i1]) && ++i1 < dataLength)
+          ;
+        previous._next = next || null;
+      }
+    }
+  }
+  update2 = new Selection(update2, parents);
+  update2._enter = enter;
+  update2._exit = exit;
+  return update2;
+}
+function arraylike(data) {
+  return typeof data === "object" && "length" in data ? data : Array.from(data);
+}
+
+// node_modules/d3-selection/src/selection/exit.js
+function exit_default() {
+  return new Selection(this._exit || this._groups.map(sparse_default), this._parents);
+}
+
+// node_modules/d3-selection/src/selection/join.js
+function join_default(onenter, onupdate, onexit) {
+  var enter = this.enter(), update2 = this, exit = this.exit();
+  if (typeof onenter === "function") {
+    enter = onenter(enter);
+    if (enter)
+      enter = enter.selection();
+  } else {
+    enter = enter.append(onenter + "");
+  }
+  if (onupdate != null) {
+    update2 = onupdate(update2);
+    if (update2)
+      update2 = update2.selection();
+  }
+  if (onexit == null)
+    exit.remove();
+  else
+    onexit(exit);
+  return enter && update2 ? enter.merge(update2).order() : update2;
+}
+
+// node_modules/d3-selection/src/selection/merge.js
+function merge_default(context) {
+  var selection = context.selection ? context.selection() : context;
+  for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0;j < m; ++j) {
+    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge3 = merges[j] = new Array(n), node, i = 0;i < n; ++i) {
+      if (node = group0[i] || group1[i]) {
+        merge3[i] = node;
+      }
+    }
+  }
+  for (;j < m0; ++j) {
+    merges[j] = groups0[j];
+  }
+  return new Selection(merges, this._parents);
+}
+
+// node_modules/d3-selection/src/selection/order.js
+function order_default() {
+  for (var groups = this._groups, j = -1, m = groups.length;++j < m; ) {
+    for (var group = groups[j], i = group.length - 1, next = group[i], node;--i >= 0; ) {
+      if (node = group[i]) {
+        if (next && node.compareDocumentPosition(next) ^ 4)
+          next.parentNode.insertBefore(node, next);
+        next = node;
+      }
+    }
+  }
+  return this;
+}
+
+// node_modules/d3-selection/src/selection/sort.js
+function sort_default(compare) {
+  if (!compare)
+    compare = ascending;
+  function compareNode(a, b) {
+    return a && b ? compare(a.__data__, b.__data__) : !a - !b;
+  }
+  for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0;j < m; ++j) {
+    for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0;i < n; ++i) {
+      if (node = group[i]) {
+        sortgroup[i] = node;
+      }
+    }
+    sortgroup.sort(compareNode);
+  }
+  return new Selection(sortgroups, this._parents).order();
+}
+function ascending(a, b) {
+  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+}
+
+// node_modules/d3-selection/src/selection/call.js
+function call_default() {
+  var callback = arguments[0];
+  arguments[0] = this;
+  callback.apply(null, arguments);
+  return this;
+}
+
+// node_modules/d3-selection/src/selection/nodes.js
+function nodes_default() {
+  return Array.from(this);
+}
+
+// node_modules/d3-selection/src/selection/node.js
+function node_default() {
+  for (var groups = this._groups, j = 0, m = groups.length;j < m; ++j) {
+    for (var group = groups[j], i = 0, n = group.length;i < n; ++i) {
+      var node = group[i];
+      if (node)
+        return node;
+    }
+  }
+  return null;
+}
+
+// node_modules/d3-selection/src/selection/size.js
+function size_default() {
+  let size = 0;
+  for (const node of this)
+    ++size;
+  return size;
+}
+
+// node_modules/d3-selection/src/selection/empty.js
+function empty_default() {
+  return !this.node();
+}
+
+// node_modules/d3-selection/src/selection/each.js
+function each_default(callback) {
+  for (var groups = this._groups, j = 0, m = groups.length;j < m; ++j) {
+    for (var group = groups[j], i = 0, n = group.length, node;i < n; ++i) {
+      if (node = group[i])
+        callback.call(node, node.__data__, i, group);
+    }
+  }
+  return this;
+}
+
+// node_modules/d3-selection/src/selection/attr.js
+function attrRemove(name) {
+  return function() {
+    this.removeAttribute(name);
+  };
+}
+function attrRemoveNS(fullname) {
+  return function() {
+    this.removeAttributeNS(fullname.space, fullname.local);
+  };
+}
+function attrConstant(name, value) {
+  return function() {
+    this.setAttribute(name, value);
+  };
+}
+function attrConstantNS(fullname, value) {
+  return function() {
+    this.setAttributeNS(fullname.space, fullname.local, value);
+  };
+}
+function attrFunction(name, value) {
+  return function() {
+    var v = value.apply(this, arguments);
+    if (v == null)
+      this.removeAttribute(name);
+    else
+      this.setAttribute(name, v);
+  };
+}
+function attrFunctionNS(fullname, value) {
+  return function() {
+    var v = value.apply(this, arguments);
+    if (v == null)
+      this.removeAttributeNS(fullname.space, fullname.local);
+    else
+      this.setAttributeNS(fullname.space, fullname.local, v);
+  };
+}
+function attr_default(name, value) {
+  var fullname = namespace_default(name);
+  if (arguments.length < 2) {
+    var node = this.node();
+    return fullname.local ? node.getAttributeNS(fullname.space, fullname.local) : node.getAttribute(fullname);
+  }
+  return this.each((value == null ? fullname.local ? attrRemoveNS : attrRemove : typeof value === "function" ? fullname.local ? attrFunctionNS : attrFunction : fullname.local ? attrConstantNS : attrConstant)(fullname, value));
+}
+
+// node_modules/d3-selection/src/window.js
+function window_default(node) {
+  return node.ownerDocument && node.ownerDocument.defaultView || node.document && node || node.defaultView;
+}
+
+// node_modules/d3-selection/src/selection/style.js
+function styleRemove(name) {
+  return function() {
+    this.style.removeProperty(name);
+  };
+}
+function styleConstant(name, value, priority) {
+  return function() {
+    this.style.setProperty(name, value, priority);
+  };
+}
+function styleFunction(name, value, priority) {
+  return function() {
+    var v = value.apply(this, arguments);
+    if (v == null)
+      this.style.removeProperty(name);
+    else
+      this.style.setProperty(name, v, priority);
+  };
+}
+function style_default(name, value, priority) {
+  return arguments.length > 1 ? this.each((value == null ? styleRemove : typeof value === "function" ? styleFunction : styleConstant)(name, value, priority == null ? "" : priority)) : styleValue(this.node(), name);
+}
+function styleValue(node, name) {
+  return node.style.getPropertyValue(name) || window_default(node).getComputedStyle(node, null).getPropertyValue(name);
+}
+
+// node_modules/d3-selection/src/selection/property.js
+function propertyRemove(name) {
+  return function() {
+    delete this[name];
+  };
+}
+function propertyConstant(name, value) {
+  return function() {
+    this[name] = value;
+  };
+}
+function propertyFunction(name, value) {
+  return function() {
+    var v = value.apply(this, arguments);
+    if (v == null)
+      delete this[name];
+    else
+      this[name] = v;
+  };
+}
+function property_default(name, value) {
+  return arguments.length > 1 ? this.each((value == null ? propertyRemove : typeof value === "function" ? propertyFunction : propertyConstant)(name, value)) : this.node()[name];
+}
+
+// node_modules/d3-selection/src/selection/classed.js
+function classArray(string) {
+  return string.trim().split(/^|\s+/);
+}
+function classList(node) {
+  return node.classList || new ClassList(node);
+}
+function ClassList(node) {
+  this._node = node;
+  this._names = classArray(node.getAttribute("class") || "");
+}
+ClassList.prototype = {
+  add: function(name) {
+    var i = this._names.indexOf(name);
+    if (i < 0) {
+      this._names.push(name);
+      this._node.setAttribute("class", this._names.join(" "));
+    }
+  },
+  remove: function(name) {
+    var i = this._names.indexOf(name);
+    if (i >= 0) {
+      this._names.splice(i, 1);
+      this._node.setAttribute("class", this._names.join(" "));
+    }
+  },
+  contains: function(name) {
+    return this._names.indexOf(name) >= 0;
+  }
+};
+function classedAdd(node, names) {
+  var list = classList(node), i = -1, n = names.length;
+  while (++i < n)
+    list.add(names[i]);
+}
+function classedRemove(node, names) {
+  var list = classList(node), i = -1, n = names.length;
+  while (++i < n)
+    list.remove(names[i]);
+}
+function classedTrue(names) {
+  return function() {
+    classedAdd(this, names);
+  };
+}
+function classedFalse(names) {
+  return function() {
+    classedRemove(this, names);
+  };
+}
+function classedFunction(names, value) {
+  return function() {
+    (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);
+  };
+}
+function classed_default(name, value) {
+  var names = classArray(name + "");
+  if (arguments.length < 2) {
+    var list = classList(this.node()), i = -1, n = names.length;
+    while (++i < n)
+      if (!list.contains(names[i]))
+        return false;
+    return true;
+  }
+  return this.each((typeof value === "function" ? classedFunction : value ? classedTrue : classedFalse)(names, value));
+}
+
+// node_modules/d3-selection/src/selection/text.js
+function textRemove() {
+  this.textContent = "";
+}
+function textConstant(value) {
+  return function() {
+    this.textContent = value;
+  };
+}
+function textFunction(value) {
+  return function() {
+    var v = value.apply(this, arguments);
+    this.textContent = v == null ? "" : v;
+  };
+}
+function text_default(value) {
+  return arguments.length ? this.each(value == null ? textRemove : (typeof value === "function" ? textFunction : textConstant)(value)) : this.node().textContent;
+}
+
+// node_modules/d3-selection/src/selection/html.js
+function htmlRemove() {
+  this.innerHTML = "";
+}
+function htmlConstant(value) {
+  return function() {
+    this.innerHTML = value;
+  };
+}
+function htmlFunction(value) {
+  return function() {
+    var v = value.apply(this, arguments);
+    this.innerHTML = v == null ? "" : v;
+  };
+}
+function html_default(value) {
+  return arguments.length ? this.each(value == null ? htmlRemove : (typeof value === "function" ? htmlFunction : htmlConstant)(value)) : this.node().innerHTML;
+}
+
+// node_modules/d3-selection/src/selection/raise.js
+function raise() {
+  if (this.nextSibling)
+    this.parentNode.appendChild(this);
+}
+function raise_default() {
+  return this.each(raise);
+}
+
+// node_modules/d3-selection/src/selection/lower.js
+function lower() {
+  if (this.previousSibling)
+    this.parentNode.insertBefore(this, this.parentNode.firstChild);
+}
+function lower_default() {
+  return this.each(lower);
+}
+
+// node_modules/d3-selection/src/selection/append.js
+function append_default(name) {
+  var create = typeof name === "function" ? name : creator_default(name);
+  return this.select(function() {
+    return this.appendChild(create.apply(this, arguments));
+  });
+}
+
+// node_modules/d3-selection/src/selection/insert.js
+function constantNull() {
+  return null;
+}
+function insert_default(name, before) {
+  var create = typeof name === "function" ? name : creator_default(name), select = before == null ? constantNull : typeof before === "function" ? before : selector_default(before);
+  return this.select(function() {
+    return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);
+  });
+}
+
+// node_modules/d3-selection/src/selection/remove.js
+function remove() {
+  var parent = this.parentNode;
+  if (parent)
+    parent.removeChild(this);
+}
+function remove_default() {
+  return this.each(remove);
+}
+
+// node_modules/d3-selection/src/selection/clone.js
+function selection_cloneShallow() {
+  var clone2 = this.cloneNode(false), parent = this.parentNode;
+  return parent ? parent.insertBefore(clone2, this.nextSibling) : clone2;
+}
+function selection_cloneDeep() {
+  var clone2 = this.cloneNode(true), parent = this.parentNode;
+  return parent ? parent.insertBefore(clone2, this.nextSibling) : clone2;
+}
+function clone_default(deep) {
+  return this.select(deep ? selection_cloneDeep : selection_cloneShallow);
+}
+
+// node_modules/d3-selection/src/selection/datum.js
+function datum_default(value) {
+  return arguments.length ? this.property("__data__", value) : this.node().__data__;
+}
+
+// node_modules/d3-selection/src/selection/on.js
+function contextListener(listener) {
+  return function(event) {
+    listener.call(this, event, this.__data__);
+  };
+}
+function parseTypenames2(typenames) {
+  return typenames.trim().split(/^|\s+/).map(function(t) {
+    var name = "", i = t.indexOf(".");
+    if (i >= 0)
+      name = t.slice(i + 1), t = t.slice(0, i);
+    return { type: t, name };
+  });
+}
+function onRemove(typename) {
+  return function() {
+    var on3 = this.__on;
+    if (!on3)
+      return;
+    for (var j = 0, i = -1, m = on3.length, o;j < m; ++j) {
+      if (o = on3[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {
+        this.removeEventListener(o.type, o.listener, o.options);
+      } else {
+        on3[++i] = o;
+      }
+    }
+    if (++i)
+      on3.length = i;
+    else
+      delete this.__on;
+  };
+}
+function onAdd(typename, value, options) {
+  return function() {
+    var on3 = this.__on, o, listener = contextListener(value);
+    if (on3)
+      for (var j = 0, m = on3.length;j < m; ++j) {
+        if ((o = on3[j]).type === typename.type && o.name === typename.name) {
+          this.removeEventListener(o.type, o.listener, o.options);
+          this.addEventListener(o.type, o.listener = listener, o.options = options);
+          o.value = value;
+          return;
+        }
+      }
+    this.addEventListener(typename.type, listener, options);
+    o = { type: typename.type, name: typename.name, value, listener, options };
+    if (!on3)
+      this.__on = [o];
+    else
+      on3.push(o);
+  };
+}
+function on_default(typename, value, options) {
+  var typenames = parseTypenames2(typename + ""), i, n = typenames.length, t;
+  if (arguments.length < 2) {
+    var on3 = this.node().__on;
+    if (on3)
+      for (var j = 0, m = on3.length, o;j < m; ++j) {
+        for (i = 0, o = on3[j];i < n; ++i) {
+          if ((t = typenames[i]).type === o.type && t.name === o.name) {
+            return o.value;
+          }
+        }
+      }
+    return;
+  }
+  on3 = value ? onAdd : onRemove;
+  for (i = 0;i < n; ++i)
+    this.each(on3(typenames[i], value, options));
+  return this;
+}
+
+// node_modules/d3-selection/src/selection/dispatch.js
+function dispatchEvent(node, type2, params) {
+  var window2 = window_default(node), event = window2.CustomEvent;
+  if (typeof event === "function") {
+    event = new event(type2, params);
+  } else {
+    event = window2.document.createEvent("Event");
+    if (params)
+      event.initEvent(type2, params.bubbles, params.cancelable), event.detail = params.detail;
+    else
+      event.initEvent(type2, false, false);
+  }
+  node.dispatchEvent(event);
+}
+function dispatchConstant(type2, params) {
+  return function() {
+    return dispatchEvent(this, type2, params);
+  };
+}
+function dispatchFunction(type2, params) {
+  return function() {
+    return dispatchEvent(this, type2, params.apply(this, arguments));
+  };
+}
+function dispatch_default2(type2, params) {
+  return this.each((typeof params === "function" ? dispatchFunction : dispatchConstant)(type2, params));
+}
+
+// node_modules/d3-selection/src/selection/iterator.js
+function* iterator_default() {
+  for (var groups = this._groups, j = 0, m = groups.length;j < m; ++j) {
+    for (var group = groups[j], i = 0, n = group.length, node;i < n; ++i) {
+      if (node = group[i])
+        yield node;
+    }
+  }
+}
+
+// node_modules/d3-selection/src/selection/index.js
+var root = [null];
+function Selection(groups, parents) {
+  this._groups = groups;
+  this._parents = parents;
+}
+function selection() {
+  return new Selection([[document.documentElement]], root);
+}
+function selection_selection() {
+  return this;
+}
+Selection.prototype = selection.prototype = {
+  constructor: Selection,
+  select: select_default,
+  selectAll: selectAll_default,
+  selectChild: selectChild_default,
+  selectChildren: selectChildren_default,
+  filter: filter_default,
+  data: data_default,
+  enter: enter_default,
+  exit: exit_default,
+  join: join_default,
+  merge: merge_default,
+  selection: selection_selection,
+  order: order_default,
+  sort: sort_default,
+  call: call_default,
+  nodes: nodes_default,
+  node: node_default,
+  size: size_default,
+  empty: empty_default,
+  each: each_default,
+  attr: attr_default,
+  style: style_default,
+  property: property_default,
+  classed: classed_default,
+  text: text_default,
+  html: html_default,
+  raise: raise_default,
+  lower: lower_default,
+  append: append_default,
+  insert: insert_default,
+  remove: remove_default,
+  clone: clone_default,
+  datum: datum_default,
+  on: on_default,
+  dispatch: dispatch_default2,
+  [Symbol.iterator]: iterator_default
+};
+var selection_default = selection;
+// node_modules/d3-color/src/define.js
+function define_default(constructor, factory, prototype) {
+  constructor.prototype = factory.prototype = prototype;
+  prototype.constructor = constructor;
+}
+function extend(parent, definition) {
+  var prototype = Object.create(parent.prototype);
+  for (var key in definition)
+    prototype[key] = definition[key];
+  return prototype;
+}
+
+// node_modules/d3-color/src/color.js
+function Color() {}
+var darker = 0.7;
+var brighter = 1 / darker;
+var reI = "\\s*([+-]?\\d+)\\s*";
+var reN = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*";
+var reP = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*";
+var reHex = /^#([0-9a-f]{3,8})$/;
+var reRgbInteger = new RegExp(`^rgb\\(${reI},${reI},${reI}\\)$`);
+var reRgbPercent = new RegExp(`^rgb\\(${reP},${reP},${reP}\\)$`);
+var reRgbaInteger = new RegExp(`^rgba\\(${reI},${reI},${reI},${reN}\\)$`);
+var reRgbaPercent = new RegExp(`^rgba\\(${reP},${reP},${reP},${reN}\\)$`);
+var reHslPercent = new RegExp(`^hsl\\(${reN},${reP},${reP}\\)$`);
+var reHslaPercent = new RegExp(`^hsla\\(${reN},${reP},${reP},${reN}\\)$`);
+var named = {
+  aliceblue: 15792383,
+  antiquewhite: 16444375,
+  aqua: 65535,
+  aquamarine: 8388564,
+  azure: 15794175,
+  beige: 16119260,
+  bisque: 16770244,
+  black: 0,
+  blanchedalmond: 16772045,
+  blue: 255,
+  blueviolet: 9055202,
+  brown: 10824234,
+  burlywood: 14596231,
+  cadetblue: 6266528,
+  chartreuse: 8388352,
+  chocolate: 13789470,
+  coral: 16744272,
+  cornflowerblue: 6591981,
+  cornsilk: 16775388,
+  crimson: 14423100,
+  cyan: 65535,
+  darkblue: 139,
+  darkcyan: 35723,
+  darkgoldenrod: 12092939,
+  darkgray: 11119017,
+  darkgreen: 25600,
+  darkgrey: 11119017,
+  darkkhaki: 12433259,
+  darkmagenta: 9109643,
+  darkolivegreen: 5597999,
+  darkorange: 16747520,
+  darkorchid: 10040012,
+  darkred: 9109504,
+  darksalmon: 15308410,
+  darkseagreen: 9419919,
+  darkslateblue: 4734347,
+  darkslategray: 3100495,
+  darkslategrey: 3100495,
+  darkturquoise: 52945,
+  darkviolet: 9699539,
+  deeppink: 16716947,
+  deepskyblue: 49151,
+  dimgray: 6908265,
+  dimgrey: 6908265,
+  dodgerblue: 2003199,
+  firebrick: 11674146,
+  floralwhite: 16775920,
+  forestgreen: 2263842,
+  fuchsia: 16711935,
+  gainsboro: 14474460,
+  ghostwhite: 16316671,
+  gold: 16766720,
+  goldenrod: 14329120,
+  gray: 8421504,
+  green: 32768,
+  greenyellow: 11403055,
+  grey: 8421504,
+  honeydew: 15794160,
+  hotpink: 16738740,
+  indianred: 13458524,
+  indigo: 4915330,
+  ivory: 16777200,
+  khaki: 15787660,
+  lavender: 15132410,
+  lavenderblush: 16773365,
+  lawngreen: 8190976,
+  lemonchiffon: 16775885,
+  lightblue: 11393254,
+  lightcoral: 15761536,
+  lightcyan: 14745599,
+  lightgoldenrodyellow: 16448210,
+  lightgray: 13882323,
+  lightgreen: 9498256,
+  lightgrey: 13882323,
+  lightpink: 16758465,
+  lightsalmon: 16752762,
+  lightseagreen: 2142890,
+  lightskyblue: 8900346,
+  lightslategray: 7833753,
+  lightslategrey: 7833753,
+  lightsteelblue: 11584734,
+  lightyellow: 16777184,
+  lime: 65280,
+  limegreen: 3329330,
+  linen: 16445670,
+  magenta: 16711935,
+  maroon: 8388608,
+  mediumaquamarine: 6737322,
+  mediumblue: 205,
+  mediumorchid: 12211667,
+  mediumpurple: 9662683,
+  mediumseagreen: 3978097,
+  mediumslateblue: 8087790,
+  mediumspringgreen: 64154,
+  mediumturquoise: 4772300,
+  mediumvioletred: 13047173,
+  midnightblue: 1644912,
+  mintcream: 16121850,
+  mistyrose: 16770273,
+  moccasin: 16770229,
+  navajowhite: 16768685,
+  navy: 128,
+  oldlace: 16643558,
+  olive: 8421376,
+  olivedrab: 7048739,
+  orange: 16753920,
+  orangered: 16729344,
+  orchid: 14315734,
+  palegoldenrod: 15657130,
+  palegreen: 10025880,
+  paleturquoise: 11529966,
+  palevioletred: 14381203,
+  papayawhip: 16773077,
+  peachpuff: 16767673,
+  peru: 13468991,
+  pink: 16761035,
+  plum: 14524637,
+  powderblue: 11591910,
+  purple: 8388736,
+  rebeccapurple: 6697881,
+  red: 16711680,
+  rosybrown: 12357519,
+  royalblue: 4286945,
+  saddlebrown: 9127187,
+  salmon: 16416882,
+  sandybrown: 16032864,
+  seagreen: 3050327,
+  seashell: 16774638,
+  sienna: 10506797,
+  silver: 12632256,
+  skyblue: 8900331,
+  slateblue: 6970061,
+  slategray: 7372944,
+  slategrey: 7372944,
+  snow: 16775930,
+  springgreen: 65407,
+  steelblue: 4620980,
+  tan: 13808780,
+  teal: 32896,
+  thistle: 14204888,
+  tomato: 16737095,
+  turquoise: 4251856,
+  violet: 15631086,
+  wheat: 16113331,
+  white: 16777215,
+  whitesmoke: 16119285,
+  yellow: 16776960,
+  yellowgreen: 10145074
+};
+define_default(Color, color, {
+  copy(channels) {
+    return Object.assign(new this.constructor, this, channels);
+  },
+  displayable() {
+    return this.rgb().displayable();
+  },
+  hex: color_formatHex,
+  formatHex: color_formatHex,
+  formatHex8: color_formatHex8,
+  formatHsl: color_formatHsl,
+  formatRgb: color_formatRgb,
+  toString: color_formatRgb
+});
+function color_formatHex() {
+  return this.rgb().formatHex();
+}
+function color_formatHex8() {
+  return this.rgb().formatHex8();
+}
+function color_formatHsl() {
+  return hslConvert(this).formatHsl();
+}
+function color_formatRgb() {
+  return this.rgb().formatRgb();
+}
+function color(format) {
+  var m, l;
+  format = (format + "").trim().toLowerCase();
+  return (m = reHex.exec(format)) ? (l = m[1].length, m = parseInt(m[1], 16), l === 6 ? rgbn(m) : l === 3 ? new Rgb(m >> 8 & 15 | m >> 4 & 240, m >> 4 & 15 | m & 240, (m & 15) << 4 | m & 15, 1) : l === 8 ? rgba(m >> 24 & 255, m >> 16 & 255, m >> 8 & 255, (m & 255) / 255) : l === 4 ? rgba(m >> 12 & 15 | m >> 8 & 240, m >> 8 & 15 | m >> 4 & 240, m >> 4 & 15 | m & 240, ((m & 15) << 4 | m & 15) / 255) : null) : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) : named.hasOwnProperty(format) ? rgbn(named[format]) : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0) : null;
+}
+function rgbn(n) {
+  return new Rgb(n >> 16 & 255, n >> 8 & 255, n & 255, 1);
+}
+function rgba(r, g, b, a) {
+  if (a <= 0)
+    r = g = b = NaN;
+  return new Rgb(r, g, b, a);
+}
+function rgbConvert(o) {
+  if (!(o instanceof Color))
+    o = color(o);
+  if (!o)
+    return new Rgb;
+  o = o.rgb();
+  return new Rgb(o.r, o.g, o.b, o.opacity);
+}
+function rgb(r, g, b, opacity) {
+  return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);
+}
+function Rgb(r, g, b, opacity) {
+  this.r = +r;
+  this.g = +g;
+  this.b = +b;
+  this.opacity = +opacity;
+}
+define_default(Rgb, rgb, extend(Color, {
+  brighter(k) {
+    k = k == null ? brighter : Math.pow(brighter, k);
+    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+  },
+  darker(k) {
+    k = k == null ? darker : Math.pow(darker, k);
+    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+  },
+  rgb() {
+    return this;
+  },
+  clamp() {
+    return new Rgb(clampi(this.r), clampi(this.g), clampi(this.b), clampa(this.opacity));
+  },
+  displayable() {
+    return -0.5 <= this.r && this.r < 255.5 && (-0.5 <= this.g && this.g < 255.5) && (-0.5 <= this.b && this.b < 255.5) && (0 <= this.opacity && this.opacity <= 1);
+  },
+  hex: rgb_formatHex,
+  formatHex: rgb_formatHex,
+  formatHex8: rgb_formatHex8,
+  formatRgb: rgb_formatRgb,
+  toString: rgb_formatRgb
+}));
+function rgb_formatHex() {
+  return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}`;
+}
+function rgb_formatHex8() {
+  return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}${hex((isNaN(this.opacity) ? 1 : this.opacity) * 255)}`;
+}
+function rgb_formatRgb() {
+  const a = clampa(this.opacity);
+  return `${a === 1 ? "rgb(" : "rgba("}${clampi(this.r)}, ${clampi(this.g)}, ${clampi(this.b)}${a === 1 ? ")" : `, ${a})`}`;
+}
+function clampa(opacity) {
+  return isNaN(opacity) ? 1 : Math.max(0, Math.min(1, opacity));
+}
+function clampi(value) {
+  return Math.max(0, Math.min(255, Math.round(value) || 0));
+}
+function hex(value) {
+  value = clampi(value);
+  return (value < 16 ? "0" : "") + value.toString(16);
+}
+function hsla(h, s, l, a) {
+  if (a <= 0)
+    h = s = l = NaN;
+  else if (l <= 0 || l >= 1)
+    h = s = NaN;
+  else if (s <= 0)
+    h = NaN;
+  return new Hsl(h, s, l, a);
+}
+function hslConvert(o) {
+  if (o instanceof Hsl)
+    return new Hsl(o.h, o.s, o.l, o.opacity);
+  if (!(o instanceof Color))
+    o = color(o);
+  if (!o)
+    return new Hsl;
+  if (o instanceof Hsl)
+    return o;
+  o = o.rgb();
+  var r = o.r / 255, g = o.g / 255, b = o.b / 255, min = Math.min(r, g, b), max = Math.max(r, g, b), h = NaN, s = max - min, l = (max + min) / 2;
+  if (s) {
+    if (r === max)
+      h = (g - b) / s + (g < b) * 6;
+    else if (g === max)
+      h = (b - r) / s + 2;
+    else
+      h = (r - g) / s + 4;
+    s /= l < 0.5 ? max + min : 2 - max - min;
+    h *= 60;
+  } else {
+    s = l > 0 && l < 1 ? 0 : h;
+  }
+  return new Hsl(h, s, l, o.opacity);
+}
+function hsl(h, s, l, opacity) {
+  return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);
+}
+function Hsl(h, s, l, opacity) {
+  this.h = +h;
+  this.s = +s;
+  this.l = +l;
+  this.opacity = +opacity;
+}
+define_default(Hsl, hsl, extend(Color, {
+  brighter(k) {
+    k = k == null ? brighter : Math.pow(brighter, k);
+    return new Hsl(this.h, this.s, this.l * k, this.opacity);
+  },
+  darker(k) {
+    k = k == null ? darker : Math.pow(darker, k);
+    return new Hsl(this.h, this.s, this.l * k, this.opacity);
+  },
+  rgb() {
+    var h = this.h % 360 + (this.h < 0) * 360, s = isNaN(h) || isNaN(this.s) ? 0 : this.s, l = this.l, m2 = l + (l < 0.5 ? l : 1 - l) * s, m1 = 2 * l - m2;
+    return new Rgb(hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), hsl2rgb(h, m1, m2), hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), this.opacity);
+  },
+  clamp() {
+    return new Hsl(clamph(this.h), clampt(this.s), clampt(this.l), clampa(this.opacity));
+  },
+  displayable() {
+    return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && (0 <= this.l && this.l <= 1) && (0 <= this.opacity && this.opacity <= 1);
+  },
+  formatHsl() {
+    const a = clampa(this.opacity);
+    return `${a === 1 ? "hsl(" : "hsla("}${clamph(this.h)}, ${clampt(this.s) * 100}%, ${clampt(this.l) * 100}%${a === 1 ? ")" : `, ${a})`}`;
+  }
+}));
+function clamph(value) {
+  value = (value || 0) % 360;
+  return value < 0 ? value + 360 : value;
+}
+function clampt(value) {
+  return Math.max(0, Math.min(1, value || 0));
+}
+function hsl2rgb(h, m1, m2) {
+  return (h < 60 ? m1 + (m2 - m1) * h / 60 : h < 180 ? m2 : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 : m1) * 255;
+}
+// node_modules/d3-interpolate/src/basis.js
+function basis(t1, v0, v1, v2, v3) {
+  var t2 = t1 * t1, t3 = t2 * t1;
+  return ((1 - 3 * t1 + 3 * t2 - t3) * v0 + (4 - 6 * t2 + 3 * t3) * v1 + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2 + t3 * v3) / 6;
+}
+function basis_default(values) {
+  var n = values.length - 1;
+  return function(t) {
+    var i = t <= 0 ? t = 0 : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n), v1 = values[i], v2 = values[i + 1], v0 = i > 0 ? values[i - 1] : 2 * v1 - v2, v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;
+    return basis((t - i / n) * n, v0, v1, v2, v3);
+  };
+}
+
+// node_modules/d3-interpolate/src/basisClosed.js
+function basisClosed_default(values) {
+  var n = values.length;
+  return function(t) {
+    var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n), v0 = values[(i + n - 1) % n], v1 = values[i % n], v2 = values[(i + 1) % n], v3 = values[(i + 2) % n];
+    return basis((t - i / n) * n, v0, v1, v2, v3);
+  };
+}
+
+// node_modules/d3-interpolate/src/constant.js
+var constant_default2 = (x) => () => x;
+
+// node_modules/d3-interpolate/src/color.js
+function linear(a, d) {
+  return function(t) {
+    return a + t * d;
+  };
+}
+function exponential(a, b, y) {
+  return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {
+    return Math.pow(a + t * b, y);
+  };
+}
+function gamma(y) {
+  return (y = +y) === 1 ? nogamma : function(a, b) {
+    return b - a ? exponential(a, b, y) : constant_default2(isNaN(a) ? b : a);
+  };
+}
+function nogamma(a, b) {
+  var d = b - a;
+  return d ? linear(a, d) : constant_default2(isNaN(a) ? b : a);
+}
+
+// node_modules/d3-interpolate/src/rgb.js
+var rgb_default = function rgbGamma(y) {
+  var color2 = gamma(y);
+  function rgb2(start, end) {
+    var r = color2((start = rgb(start)).r, (end = rgb(end)).r), g = color2(start.g, end.g), b = color2(start.b, end.b), opacity = nogamma(start.opacity, end.opacity);
+    return function(t) {
+      start.r = r(t);
+      start.g = g(t);
+      start.b = b(t);
+      start.opacity = opacity(t);
+      return start + "";
+    };
+  }
+  rgb2.gamma = rgbGamma;
+  return rgb2;
+}(1);
+function rgbSpline(spline) {
+  return function(colors) {
+    var n = colors.length, r = new Array(n), g = new Array(n), b = new Array(n), i, color2;
+    for (i = 0;i < n; ++i) {
+      color2 = rgb(colors[i]);
+      r[i] = color2.r || 0;
+      g[i] = color2.g || 0;
+      b[i] = color2.b || 0;
+    }
+    r = spline(r);
+    g = spline(g);
+    b = spline(b);
+    color2.opacity = 1;
+    return function(t) {
+      color2.r = r(t);
+      color2.g = g(t);
+      color2.b = b(t);
+      return color2 + "";
+    };
+  };
+}
+var rgbBasis = rgbSpline(basis_default);
+var rgbBasisClosed = rgbSpline(basisClosed_default);
+
+// node_modules/d3-interpolate/src/number.js
+function number_default(a, b) {
+  return a = +a, b = +b, function(t) {
+    return a * (1 - t) + b * t;
+  };
+}
+
+// node_modules/d3-interpolate/src/string.js
+var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g;
+var reB = new RegExp(reA.source, "g");
+function zero(b) {
+  return function() {
+    return b;
+  };
+}
+function one(b) {
+  return function(t) {
+    return b(t) + "";
+  };
+}
+function string_default(a, b) {
+  var bi = reA.lastIndex = reB.lastIndex = 0, am, bm, bs, i = -1, s = [], q = [];
+  a = a + "", b = b + "";
+  while ((am = reA.exec(a)) && (bm = reB.exec(b))) {
+    if ((bs = bm.index) > bi) {
+      bs = b.slice(bi, bs);
+      if (s[i])
+        s[i] += bs;
+      else
+        s[++i] = bs;
+    }
+    if ((am = am[0]) === (bm = bm[0])) {
+      if (s[i])
+        s[i] += bm;
+      else
+        s[++i] = bm;
+    } else {
+      s[++i] = null;
+      q.push({ i, x: number_default(am, bm) });
+    }
+    bi = reB.lastIndex;
+  }
+  if (bi < b.length) {
+    bs = b.slice(bi);
+    if (s[i])
+      s[i] += bs;
+    else
+      s[++i] = bs;
+  }
+  return s.length < 2 ? q[0] ? one(q[0].x) : zero(b) : (b = q.length, function(t) {
+    for (var i2 = 0, o;i2 < b; ++i2)
+      s[(o = q[i2]).i] = o.x(t);
+    return s.join("");
+  });
+}
+// node_modules/d3-interpolate/src/transform/decompose.js
+var degrees = 180 / Math.PI;
+var identity = {
+  translateX: 0,
+  translateY: 0,
+  rotate: 0,
+  skewX: 0,
+  scaleX: 1,
+  scaleY: 1
+};
+function decompose_default(a, b, c, d, e, f) {
+  var scaleX, scaleY, skewX;
+  if (scaleX = Math.sqrt(a * a + b * b))
+    a /= scaleX, b /= scaleX;
+  if (skewX = a * c + b * d)
+    c -= a * skewX, d -= b * skewX;
+  if (scaleY = Math.sqrt(c * c + d * d))
+    c /= scaleY, d /= scaleY, skewX /= scaleY;
+  if (a * d < b * c)
+    a = -a, b = -b, skewX = -skewX, scaleX = -scaleX;
+  return {
+    translateX: e,
+    translateY: f,
+    rotate: Math.atan2(b, a) * degrees,
+    skewX: Math.atan(skewX) * degrees,
+    scaleX,
+    scaleY
+  };
+}
+
+// node_modules/d3-interpolate/src/transform/parse.js
+var svgNode;
+function parseCss(value) {
+  const m = new (typeof DOMMatrix === "function" ? DOMMatrix : WebKitCSSMatrix)(value + "");
+  return m.isIdentity ? identity : decompose_default(m.a, m.b, m.c, m.d, m.e, m.f);
+}
+function parseSvg(value) {
+  if (value == null)
+    return identity;
+  if (!svgNode)
+    svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g");
+  svgNode.setAttribute("transform", value);
+  if (!(value = svgNode.transform.baseVal.consolidate()))
+    return identity;
+  value = value.matrix;
+  return decompose_default(value.a, value.b, value.c, value.d, value.e, value.f);
+}
+
+// node_modules/d3-interpolate/src/transform/index.js
+function interpolateTransform(parse, pxComma, pxParen, degParen) {
+  function pop(s) {
+    return s.length ? s.pop() + " " : "";
+  }
+  function translate(xa, ya, xb, yb, s, q) {
+    if (xa !== xb || ya !== yb) {
+      var i = s.push("translate(", null, pxComma, null, pxParen);
+      q.push({ i: i - 4, x: number_default(xa, xb) }, { i: i - 2, x: number_default(ya, yb) });
+    } else if (xb || yb) {
+      s.push("translate(" + xb + pxComma + yb + pxParen);
+    }
+  }
+  function rotate(a, b, s, q) {
+    if (a !== b) {
+      if (a - b > 180)
+        b += 360;
+      else if (b - a > 180)
+        a += 360;
+      q.push({ i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: number_default(a, b) });
+    } else if (b) {
+      s.push(pop(s) + "rotate(" + b + degParen);
+    }
+  }
+  function skewX(a, b, s, q) {
+    if (a !== b) {
+      q.push({ i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: number_default(a, b) });
+    } else if (b) {
+      s.push(pop(s) + "skewX(" + b + degParen);
+    }
+  }
+  function scale(xa, ya, xb, yb, s, q) {
+    if (xa !== xb || ya !== yb) {
+      var i = s.push(pop(s) + "scale(", null, ",", null, ")");
+      q.push({ i: i - 4, x: number_default(xa, xb) }, { i: i - 2, x: number_default(ya, yb) });
+    } else if (xb !== 1 || yb !== 1) {
+      s.push(pop(s) + "scale(" + xb + "," + yb + ")");
+    }
+  }
+  return function(a, b) {
+    var s = [], q = [];
+    a = parse(a), b = parse(b);
+    translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q);
+    rotate(a.rotate, b.rotate, s, q);
+    skewX(a.skewX, b.skewX, s, q);
+    scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q);
+    a = b = null;
+    return function(t) {
+      var i = -1, n = q.length, o;
+      while (++i < n)
+        s[(o = q[i]).i] = o.x(t);
+      return s.join("");
+    };
+  };
+}
+var interpolateTransformCss = interpolateTransform(parseCss, "px, ", "px)", "deg)");
+var interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")");
+// node_modules/d3-timer/src/timer.js
+var frame = 0;
+var timeout2 = 0;
+var interval = 0;
+var pokeDelay = 1000;
+var taskHead;
+var taskTail;
+var clockLast = 0;
+var clockNow = 0;
+var clockSkew = 0;
+var clock = typeof performance === "object" && performance.now ? performance : Date;
+var setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) {
+  setTimeout(f, 17);
+};
+function now() {
+  return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);
+}
+function clearNow() {
+  clockNow = 0;
+}
+function Timer() {
+  this._call = this._time = this._next = null;
+}
+Timer.prototype = timer.prototype = {
+  constructor: Timer,
+  restart: function(callback, delay, time) {
+    if (typeof callback !== "function")
+      throw new TypeError("callback is not a function");
+    time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);
+    if (!this._next && taskTail !== this) {
+      if (taskTail)
+        taskTail._next = this;
+      else
+        taskHead = this;
+      taskTail = this;
+    }
+    this._call = callback;
+    this._time = time;
+    sleep();
+  },
+  stop: function() {
+    if (this._call) {
+      this._call = null;
+      this._time = Infinity;
+      sleep();
+    }
+  }
+};
+function timer(callback, delay, time) {
+  var t = new Timer;
+  t.restart(callback, delay, time);
+  return t;
+}
+function timerFlush() {
+  now();
+  ++frame;
+  var t = taskHead, e;
+  while (t) {
+    if ((e = clockNow - t._time) >= 0)
+      t._call.call(undefined, e);
+    t = t._next;
+  }
+  --frame;
+}
+function wake() {
+  clockNow = (clockLast = clock.now()) + clockSkew;
+  frame = timeout2 = 0;
+  try {
+    timerFlush();
+  } finally {
+    frame = 0;
+    nap();
+    clockNow = 0;
+  }
+}
+function poke() {
+  var now2 = clock.now(), delay = now2 - clockLast;
+  if (delay > pokeDelay)
+    clockSkew -= delay, clockLast = now2;
+}
+function nap() {
+  var t0, t1 = taskHead, t2, time = Infinity;
+  while (t1) {
+    if (t1._call) {
+      if (time > t1._time)
+        time = t1._time;
+      t0 = t1, t1 = t1._next;
+    } else {
+      t2 = t1._next, t1._next = null;
+      t1 = t0 ? t0._next = t2 : taskHead = t2;
+    }
+  }
+  taskTail = t0;
+  sleep(time);
+}
+function sleep(time) {
+  if (frame)
+    return;
+  if (timeout2)
+    timeout2 = clearTimeout(timeout2);
+  var delay = time - clockNow;
+  if (delay > 24) {
+    if (time < Infinity)
+      timeout2 = setTimeout(wake, time - clock.now() - clockSkew);
+    if (interval)
+      interval = clearInterval(interval);
+  } else {
+    if (!interval)
+      clockLast = clock.now(), interval = setInterval(poke, pokeDelay);
+    frame = 1, setFrame(wake);
+  }
+}
+// node_modules/d3-timer/src/timeout.js
+function timeout_default(callback, delay, time) {
+  var t = new Timer;
+  delay = delay == null ? 0 : +delay;
+  t.restart((elapsed) => {
+    t.stop();
+    callback(elapsed + delay);
+  }, delay, time);
+  return t;
+}
+// node_modules/d3-transition/src/transition/schedule.js
+var emptyOn = dispatch_default("start", "end", "cancel", "interrupt");
+var emptyTween = [];
+var CREATED = 0;
+var SCHEDULED = 1;
+var STARTING = 2;
+var STARTED = 3;
+var RUNNING = 4;
+var ENDING = 5;
+var ENDED = 6;
+function schedule_default(node, name, id, index, group, timing) {
+  var schedules = node.__transition;
+  if (!schedules)
+    node.__transition = {};
+  else if (id in schedules)
+    return;
+  create(node, id, {
+    name,
+    index,
+    group,
+    on: emptyOn,
+    tween: emptyTween,
+    time: timing.time,
+    delay: timing.delay,
+    duration: timing.duration,
+    ease: timing.ease,
+    timer: null,
+    state: CREATED
+  });
+}
+function init(node, id) {
+  var schedule4 = get2(node, id);
+  if (schedule4.state > CREATED)
+    throw new Error("too late; already scheduled");
+  return schedule4;
+}
+function set3(node, id) {
+  var schedule4 = get2(node, id);
+  if (schedule4.state > STARTED)
+    throw new Error("too late; already running");
+  return schedule4;
+}
+function get2(node, id) {
+  var schedule4 = node.__transition;
+  if (!schedule4 || !(schedule4 = schedule4[id]))
+    throw new Error("transition not found");
+  return schedule4;
+}
+function create(node, id, self) {
+  var schedules = node.__transition, tween;
+  schedules[id] = self;
+  self.timer = timer(schedule4, 0, self.time);
+  function schedule4(elapsed) {
+    self.state = SCHEDULED;
+    self.timer.restart(start, self.delay, self.time);
+    if (self.delay <= elapsed)
+      start(elapsed - self.delay);
+  }
+  function start(elapsed) {
+    var i, j, n, o;
+    if (self.state !== SCHEDULED)
+      return stop();
+    for (i in schedules) {
+      o = schedules[i];
+      if (o.name !== self.name)
+        continue;
+      if (o.state === STARTED)
+        return timeout_default(start);
+      if (o.state === RUNNING) {
+        o.state = ENDED;
+        o.timer.stop();
+        o.on.call("interrupt", node, node.__data__, o.index, o.group);
+        delete schedules[i];
+      } else if (+i < id) {
+        o.state = ENDED;
+        o.timer.stop();
+        o.on.call("cancel", node, node.__data__, o.index, o.group);
+        delete schedules[i];
+      }
+    }
+    timeout_default(function() {
+      if (self.state === STARTED) {
+        self.state = RUNNING;
+        self.timer.restart(tick, self.delay, self.time);
+        tick(elapsed);
+      }
+    });
+    self.state = STARTING;
+    self.on.call("start", node, node.__data__, self.index, self.group);
+    if (self.state !== STARTING)
+      return;
+    self.state = STARTED;
+    tween = new Array(n = self.tween.length);
+    for (i = 0, j = -1;i < n; ++i) {
+      if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) {
+        tween[++j] = o;
+      }
+    }
+    tween.length = j + 1;
+  }
+  function tick(elapsed) {
+    var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1), i = -1, n = tween.length;
+    while (++i < n) {
+      tween[i].call(node, t);
+    }
+    if (self.state === ENDING) {
+      self.on.call("end", node, node.__data__, self.index, self.group);
+      stop();
+    }
+  }
+  function stop() {
+    self.state = ENDED;
+    self.timer.stop();
+    delete schedules[id];
+    for (var i in schedules)
+      return;
+    delete node.__transition;
+  }
+}
+
+// node_modules/d3-transition/src/interrupt.js
+function interrupt_default(node, name) {
+  var schedules = node.__transition, schedule4, active, empty2 = true, i;
+  if (!schedules)
+    return;
+  name = name == null ? null : name + "";
+  for (i in schedules) {
+    if ((schedule4 = schedules[i]).name !== name) {
+      empty2 = false;
+      continue;
+    }
+    active = schedule4.state > STARTING && schedule4.state < ENDING;
+    schedule4.state = ENDED;
+    schedule4.timer.stop();
+    schedule4.on.call(active ? "interrupt" : "cancel", node, node.__data__, schedule4.index, schedule4.group);
+    delete schedules[i];
+  }
+  if (empty2)
+    delete node.__transition;
+}
+
+// node_modules/d3-transition/src/selection/interrupt.js
+function interrupt_default2(name) {
+  return this.each(function() {
+    interrupt_default(this, name);
+  });
+}
+
+// node_modules/d3-transition/src/transition/tween.js
+function tweenRemove(id, name) {
+  var tween0, tween1;
+  return function() {
+    var schedule4 = set3(this, id), tween = schedule4.tween;
+    if (tween !== tween0) {
+      tween1 = tween0 = tween;
+      for (var i = 0, n = tween1.length;i < n; ++i) {
+        if (tween1[i].name === name) {
+          tween1 = tween1.slice();
+          tween1.splice(i, 1);
+          break;
+        }
+      }
+    }
+    schedule4.tween = tween1;
+  };
+}
+function tweenFunction(id, name, value) {
+  var tween0, tween1;
+  if (typeof value !== "function")
+    throw new Error;
+  return function() {
+    var schedule4 = set3(this, id), tween = schedule4.tween;
+    if (tween !== tween0) {
+      tween1 = (tween0 = tween).slice();
+      for (var t = { name, value }, i = 0, n = tween1.length;i < n; ++i) {
+        if (tween1[i].name === name) {
+          tween1[i] = t;
+          break;
+        }
+      }
+      if (i === n)
+        tween1.push(t);
+    }
+    schedule4.tween = tween1;
+  };
+}
+function tween_default(name, value) {
+  var id = this._id;
+  name += "";
+  if (arguments.length < 2) {
+    var tween = get2(this.node(), id).tween;
+    for (var i = 0, n = tween.length, t;i < n; ++i) {
+      if ((t = tween[i]).name === name) {
+        return t.value;
+      }
+    }
+    return null;
+  }
+  return this.each((value == null ? tweenRemove : tweenFunction)(id, name, value));
+}
+function tweenValue(transition, name, value) {
+  var id = transition._id;
+  transition.each(function() {
+    var schedule4 = set3(this, id);
+    (schedule4.value || (schedule4.value = {}))[name] = value.apply(this, arguments);
+  });
+  return function(node) {
+    return get2(node, id).value[name];
+  };
+}
+
+// node_modules/d3-transition/src/transition/interpolate.js
+function interpolate_default(a, b) {
+  var c;
+  return (typeof b === "number" ? number_default : b instanceof color ? rgb_default : (c = color(b)) ? (b = c, rgb_default) : string_default)(a, b);
+}
+
+// node_modules/d3-transition/src/transition/attr.js
+function attrRemove2(name) {
+  return function() {
+    this.removeAttribute(name);
+  };
+}
+function attrRemoveNS2(fullname) {
+  return function() {
+    this.removeAttributeNS(fullname.space, fullname.local);
+  };
+}
+function attrConstant2(name, interpolate, value1) {
+  var string00, string1 = value1 + "", interpolate0;
+  return function() {
+    var string0 = this.getAttribute(name);
+    return string0 === string1 ? null : string0 === string00 ? interpolate0 : interpolate0 = interpolate(string00 = string0, value1);
+  };
+}
+function attrConstantNS2(fullname, interpolate, value1) {
+  var string00, string1 = value1 + "", interpolate0;
+  return function() {
+    var string0 = this.getAttributeNS(fullname.space, fullname.local);
+    return string0 === string1 ? null : string0 === string00 ? interpolate0 : interpolate0 = interpolate(string00 = string0, value1);
+  };
+}
+function attrFunction2(name, interpolate, value) {
+  var string00, string10, interpolate0;
+  return function() {
+    var string0, value1 = value(this), string1;
+    if (value1 == null)
+      return void this.removeAttribute(name);
+    string0 = this.getAttribute(name);
+    string1 = value1 + "";
+    return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
+  };
+}
+function attrFunctionNS2(fullname, interpolate, value) {
+  var string00, string10, interpolate0;
+  return function() {
+    var string0, value1 = value(this), string1;
+    if (value1 == null)
+      return void this.removeAttributeNS(fullname.space, fullname.local);
+    string0 = this.getAttributeNS(fullname.space, fullname.local);
+    string1 = value1 + "";
+    return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
+  };
+}
+function attr_default2(name, value) {
+  var fullname = namespace_default(name), i = fullname === "transform" ? interpolateTransformSvg : interpolate_default;
+  return this.attrTween(name, typeof value === "function" ? (fullname.local ? attrFunctionNS2 : attrFunction2)(fullname, i, tweenValue(this, "attr." + name, value)) : value == null ? (fullname.local ? attrRemoveNS2 : attrRemove2)(fullname) : (fullname.local ? attrConstantNS2 : attrConstant2)(fullname, i, value));
+}
+
+// node_modules/d3-transition/src/transition/attrTween.js
+function attrInterpolate(name, i) {
+  return function(t) {
+    this.setAttribute(name, i.call(this, t));
+  };
+}
+function attrInterpolateNS(fullname, i) {
+  return function(t) {
+    this.setAttributeNS(fullname.space, fullname.local, i.call(this, t));
+  };
+}
+function attrTweenNS(fullname, value) {
+  var t0, i0;
+  function tween() {
+    var i = value.apply(this, arguments);
+    if (i !== i0)
+      t0 = (i0 = i) && attrInterpolateNS(fullname, i);
+    return t0;
+  }
+  tween._value = value;
+  return tween;
+}
+function attrTween(name, value) {
+  var t0, i0;
+  function tween() {
+    var i = value.apply(this, arguments);
+    if (i !== i0)
+      t0 = (i0 = i) && attrInterpolate(name, i);
+    return t0;
+  }
+  tween._value = value;
+  return tween;
+}
+function attrTween_default(name, value) {
+  var key = "attr." + name;
+  if (arguments.length < 2)
+    return (key = this.tween(key)) && key._value;
+  if (value == null)
+    return this.tween(key, null);
+  if (typeof value !== "function")
+    throw new Error;
+  var fullname = namespace_default(name);
+  return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value));
+}
+
+// node_modules/d3-transition/src/transition/delay.js
+function delayFunction(id, value) {
+  return function() {
+    init(this, id).delay = +value.apply(this, arguments);
+  };
+}
+function delayConstant(id, value) {
+  return value = +value, function() {
+    init(this, id).delay = value;
+  };
+}
+function delay_default(value) {
+  var id = this._id;
+  return arguments.length ? this.each((typeof value === "function" ? delayFunction : delayConstant)(id, value)) : get2(this.node(), id).delay;
+}
+
+// node_modules/d3-transition/src/transition/duration.js
+function durationFunction(id, value) {
+  return function() {
+    set3(this, id).duration = +value.apply(this, arguments);
+  };
+}
+function durationConstant(id, value) {
+  return value = +value, function() {
+    set3(this, id).duration = value;
+  };
+}
+function duration_default(value) {
+  var id = this._id;
+  return arguments.length ? this.each((typeof value === "function" ? durationFunction : durationConstant)(id, value)) : get2(this.node(), id).duration;
+}
+
+// node_modules/d3-transition/src/transition/ease.js
+function easeConstant(id, value) {
+  if (typeof value !== "function")
+    throw new Error;
+  return function() {
+    set3(this, id).ease = value;
+  };
+}
+function ease_default(value) {
+  var id = this._id;
+  return arguments.length ? this.each(easeConstant(id, value)) : get2(this.node(), id).ease;
+}
+
+// node_modules/d3-transition/src/transition/easeVarying.js
+function easeVarying(id, value) {
+  return function() {
+    var v = value.apply(this, arguments);
+    if (typeof v !== "function")
+      throw new Error;
+    set3(this, id).ease = v;
+  };
+}
+function easeVarying_default(value) {
+  if (typeof value !== "function")
+    throw new Error;
+  return this.each(easeVarying(this._id, value));
+}
+
+// node_modules/d3-transition/src/transition/filter.js
+function filter_default2(match) {
+  if (typeof match !== "function")
+    match = matcher_default(match);
+  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0;j < m; ++j) {
+    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0;i < n; ++i) {
+      if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
+        subgroup.push(node);
+      }
+    }
+  }
+  return new Transition(subgroups, this._parents, this._name, this._id);
+}
+
+// node_modules/d3-transition/src/transition/merge.js
+function merge_default2(transition) {
+  if (transition._id !== this._id)
+    throw new Error;
+  for (var groups0 = this._groups, groups1 = transition._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0;j < m; ++j) {
+    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge3 = merges[j] = new Array(n), node, i = 0;i < n; ++i) {
+      if (node = group0[i] || group1[i]) {
+        merge3[i] = node;
+      }
+    }
+  }
+  for (;j < m0; ++j) {
+    merges[j] = groups0[j];
+  }
+  return new Transition(merges, this._parents, this._name, this._id);
+}
+
+// node_modules/d3-transition/src/transition/on.js
+function start(name) {
+  return (name + "").trim().split(/^|\s+/).every(function(t) {
+    var i = t.indexOf(".");
+    if (i >= 0)
+      t = t.slice(0, i);
+    return !t || t === "start";
+  });
+}
+function onFunction(id, name, listener) {
+  var on0, on1, sit = start(name) ? init : set3;
+  return function() {
+    var schedule4 = sit(this, id), on3 = schedule4.on;
+    if (on3 !== on0)
+      (on1 = (on0 = on3).copy()).on(name, listener);
+    schedule4.on = on1;
+  };
+}
+function on_default2(name, listener) {
+  var id = this._id;
+  return arguments.length < 2 ? get2(this.node(), id).on.on(name) : this.each(onFunction(id, name, listener));
+}
+
+// node_modules/d3-transition/src/transition/remove.js
+function removeFunction(id) {
+  return function() {
+    var parent = this.parentNode;
+    for (var i in this.__transition)
+      if (+i !== id)
+        return;
+    if (parent)
+      parent.removeChild(this);
+  };
+}
+function remove_default2() {
+  return this.on("end.remove", removeFunction(this._id));
+}
+
+// node_modules/d3-transition/src/transition/select.js
+function select_default2(select) {
+  var name = this._name, id = this._id;
+  if (typeof select !== "function")
+    select = selector_default(select);
+  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0;j < m; ++j) {
+    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0;i < n; ++i) {
+      if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
+        if ("__data__" in node)
+          subnode.__data__ = node.__data__;
+        subgroup[i] = subnode;
+        schedule_default(subgroup[i], name, id, i, subgroup, get2(node, id));
+      }
+    }
+  }
+  return new Transition(subgroups, this._parents, name, id);
+}
+
+// node_modules/d3-transition/src/transition/selectAll.js
+function selectAll_default2(select) {
+  var name = this._name, id = this._id;
+  if (typeof select !== "function")
+    select = selectorAll_default(select);
+  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0;j < m; ++j) {
+    for (var group = groups[j], n = group.length, node, i = 0;i < n; ++i) {
+      if (node = group[i]) {
+        for (var children2 = select.call(node, node.__data__, i, group), child, inherit = get2(node, id), k = 0, l = children2.length;k < l; ++k) {
+          if (child = children2[k]) {
+            schedule_default(child, name, id, k, children2, inherit);
+          }
+        }
+        subgroups.push(children2);
+        parents.push(node);
+      }
+    }
+  }
+  return new Transition(subgroups, parents, name, id);
+}
+
+// node_modules/d3-transition/src/transition/selection.js
+var Selection2 = selection_default.prototype.constructor;
+function selection_default2() {
+  return new Selection2(this._groups, this._parents);
+}
+
+// node_modules/d3-transition/src/transition/style.js
+function styleNull(name, interpolate) {
+  var string00, string10, interpolate0;
+  return function() {
+    var string0 = styleValue(this, name), string1 = (this.style.removeProperty(name), styleValue(this, name));
+    return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : interpolate0 = interpolate(string00 = string0, string10 = string1);
+  };
+}
+function styleRemove2(name) {
+  return function() {
+    this.style.removeProperty(name);
+  };
+}
+function styleConstant2(name, interpolate, value1) {
+  var string00, string1 = value1 + "", interpolate0;
+  return function() {
+    var string0 = styleValue(this, name);
+    return string0 === string1 ? null : string0 === string00 ? interpolate0 : interpolate0 = interpolate(string00 = string0, value1);
+  };
+}
+function styleFunction2(name, interpolate, value) {
+  var string00, string10, interpolate0;
+  return function() {
+    var string0 = styleValue(this, name), value1 = value(this), string1 = value1 + "";
+    if (value1 == null)
+      string1 = value1 = (this.style.removeProperty(name), styleValue(this, name));
+    return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
+  };
+}
+function styleMaybeRemove(id, name) {
+  var on0, on1, listener0, key = "style." + name, event = "end." + key, remove2;
+  return function() {
+    var schedule4 = set3(this, id), on3 = schedule4.on, listener = schedule4.value[key] == null ? remove2 || (remove2 = styleRemove2(name)) : undefined;
+    if (on3 !== on0 || listener0 !== listener)
+      (on1 = (on0 = on3).copy()).on(event, listener0 = listener);
+    schedule4.on = on1;
+  };
+}
+function style_default2(name, value, priority) {
+  var i = (name += "") === "transform" ? interpolateTransformCss : interpolate_default;
+  return value == null ? this.styleTween(name, styleNull(name, i)).on("end.style." + name, styleRemove2(name)) : typeof value === "function" ? this.styleTween(name, styleFunction2(name, i, tweenValue(this, "style." + name, value))).each(styleMaybeRemove(this._id, name)) : this.styleTween(name, styleConstant2(name, i, value), priority).on("end.style." + name, null);
+}
+
+// node_modules/d3-transition/src/transition/styleTween.js
+function styleInterpolate(name, i, priority) {
+  return function(t) {
+    this.style.setProperty(name, i.call(this, t), priority);
+  };
+}
+function styleTween(name, value, priority) {
+  var t, i0;
+  function tween() {
+    var i = value.apply(this, arguments);
+    if (i !== i0)
+      t = (i0 = i) && styleInterpolate(name, i, priority);
+    return t;
+  }
+  tween._value = value;
+  return tween;
+}
+function styleTween_default(name, value, priority) {
+  var key = "style." + (name += "");
+  if (arguments.length < 2)
+    return (key = this.tween(key)) && key._value;
+  if (value == null)
+    return this.tween(key, null);
+  if (typeof value !== "function")
+    throw new Error;
+  return this.tween(key, styleTween(name, value, priority == null ? "" : priority));
+}
+
+// node_modules/d3-transition/src/transition/text.js
+function textConstant2(value) {
+  return function() {
+    this.textContent = value;
+  };
+}
+function textFunction2(value) {
+  return function() {
+    var value1 = value(this);
+    this.textContent = value1 == null ? "" : value1;
+  };
+}
+function text_default2(value) {
+  return this.tween("text", typeof value === "function" ? textFunction2(tweenValue(this, "text", value)) : textConstant2(value == null ? "" : value + ""));
+}
+
+// node_modules/d3-transition/src/transition/textTween.js
+function textInterpolate(i) {
+  return function(t) {
+    this.textContent = i.call(this, t);
+  };
+}
+function textTween(value) {
+  var t0, i0;
+  function tween() {
+    var i = value.apply(this, arguments);
+    if (i !== i0)
+      t0 = (i0 = i) && textInterpolate(i);
+    return t0;
+  }
+  tween._value = value;
+  return tween;
+}
+function textTween_default(value) {
+  var key = "text";
+  if (arguments.length < 1)
+    return (key = this.tween(key)) && key._value;
+  if (value == null)
+    return this.tween(key, null);
+  if (typeof value !== "function")
+    throw new Error;
+  return this.tween(key, textTween(value));
+}
+
+// node_modules/d3-transition/src/transition/transition.js
+function transition_default() {
+  var name = this._name, id0 = this._id, id1 = newId();
+  for (var groups = this._groups, m = groups.length, j = 0;j < m; ++j) {
+    for (var group = groups[j], n = group.length, node, i = 0;i < n; ++i) {
+      if (node = group[i]) {
+        var inherit = get2(node, id0);
+        schedule_default(node, name, id1, i, group, {
+          time: inherit.time + inherit.delay + inherit.duration,
+          delay: 0,
+          duration: inherit.duration,
+          ease: inherit.ease
+        });
+      }
+    }
+  }
+  return new Transition(groups, this._parents, name, id1);
+}
+
+// node_modules/d3-transition/src/transition/end.js
+function end_default() {
+  var on0, on1, that = this, id = that._id, size = that.size();
+  return new Promise(function(resolve, reject) {
+    var cancel = { value: reject }, end = { value: function() {
+      if (--size === 0)
+        resolve();
+    } };
+    that.each(function() {
+      var schedule4 = set3(this, id), on3 = schedule4.on;
+      if (on3 !== on0) {
+        on1 = (on0 = on3).copy();
+        on1._.cancel.push(cancel);
+        on1._.interrupt.push(cancel);
+        on1._.end.push(end);
+      }
+      schedule4.on = on1;
+    });
+    if (size === 0)
+      resolve();
+  });
+}
+
+// node_modules/d3-transition/src/transition/index.js
+var id = 0;
+function Transition(groups, parents, name, id2) {
+  this._groups = groups;
+  this._parents = parents;
+  this._name = name;
+  this._id = id2;
+}
+function transition(name) {
+  return selection_default().transition(name);
+}
+function newId() {
+  return ++id;
+}
+var selection_prototype = selection_default.prototype;
+Transition.prototype = transition.prototype = {
+  constructor: Transition,
+  select: select_default2,
+  selectAll: selectAll_default2,
+  selectChild: selection_prototype.selectChild,
+  selectChildren: selection_prototype.selectChildren,
+  filter: filter_default2,
+  merge: merge_default2,
+  selection: selection_default2,
+  transition: transition_default,
+  call: selection_prototype.call,
+  nodes: selection_prototype.nodes,
+  node: selection_prototype.node,
+  size: selection_prototype.size,
+  empty: selection_prototype.empty,
+  each: selection_prototype.each,
+  on: on_default2,
+  attr: attr_default2,
+  attrTween: attrTween_default,
+  style: style_default2,
+  styleTween: styleTween_default,
+  text: text_default2,
+  textTween: textTween_default,
+  remove: remove_default2,
+  tween: tween_default,
+  delay: delay_default,
+  duration: duration_default,
+  ease: ease_default,
+  easeVarying: easeVarying_default,
+  end: end_default,
+  [Symbol.iterator]: selection_prototype[Symbol.iterator]
+};
+
+// node_modules/d3-ease/src/cubic.js
+function cubicInOut(t) {
+  return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;
+}
+// node_modules/d3-transition/src/selection/transition.js
+var defaultTiming = {
+  time: null,
+  delay: 0,
+  duration: 250,
+  ease: cubicInOut
+};
+function inherit(node, id2) {
+  var timing;
+  while (!(timing = node.__transition) || !(timing = timing[id2])) {
+    if (!(node = node.parentNode)) {
+      throw new Error(`transition ${id2} not found`);
+    }
+  }
+  return timing;
+}
+function transition_default2(name) {
+  var id2, timing;
+  if (name instanceof Transition) {
+    id2 = name._id, name = name._name;
+  } else {
+    id2 = newId(), (timing = defaultTiming).time = now(), name = name == null ? null : name + "";
+  }
+  for (var groups = this._groups, m = groups.length, j = 0;j < m; ++j) {
+    for (var group = groups[j], n = group.length, node, i = 0;i < n; ++i) {
+      if (node = group[i]) {
+        schedule_default(node, name, id2, i, group, timing || inherit(node, id2));
+      }
+    }
+  }
+  return new Transition(groups, this._parents, name, id2);
+}
+
+// node_modules/d3-transition/src/selection/index.js
+selection_default.prototype.interrupt = interrupt_default2;
+selection_default.prototype.transition = transition_default2;
+
+// node_modules/d3-brush/src/brush.js
+function number1(e) {
+  return [+e[0], +e[1]];
+}
+function number2(e) {
+  return [number1(e[0]), number1(e[1])];
+}
+var X = {
+  name: "x",
+  handles: ["w", "e"].map(type2),
+  input: function(x, e) {
+    return x == null ? null : [[+x[0], e[0][1]], [+x[1], e[1][1]]];
+  },
+  output: function(xy) {
+    return xy && [xy[0][0], xy[1][0]];
+  }
+};
+var Y = {
+  name: "y",
+  handles: ["n", "s"].map(type2),
+  input: function(y, e) {
+    return y == null ? null : [[e[0][0], +y[0]], [e[1][0], +y[1]]];
+  },
+  output: function(xy) {
+    return xy && [xy[0][1], xy[1][1]];
+  }
+};
+var XY = {
+  name: "xy",
+  handles: ["n", "w", "e", "s", "nw", "ne", "sw", "se"].map(type2),
+  input: function(xy) {
+    return xy == null ? null : number2(xy);
+  },
+  output: function(xy) {
+    return xy;
+  }
+};
+function type2(t) {
+  return { type: t };
+}
+// node_modules/d3-dsv/src/dsv.js
+var EOL = {};
+var EOF = {};
+var QUOTE = 34;
+var NEWLINE = 10;
+var RETURN = 13;
+function objectConverter(columns) {
+  return new Function("d", "return {" + columns.map(function(name, i) {
+    return JSON.stringify(name) + ": d[" + i + '] || ""';
+  }).join(",") + "}");
+}
+function customConverter(columns, f) {
+  var object = objectConverter(columns);
+  return function(row, i) {
+    return f(object(row), i, columns);
+  };
+}
+function inferColumns(rows) {
+  var columnSet = Object.create(null), columns = [];
+  rows.forEach(function(row) {
+    for (var column in row) {
+      if (!(column in columnSet)) {
+        columns.push(columnSet[column] = column);
+      }
+    }
+  });
+  return columns;
+}
+function pad(value, width) {
+  var s = value + "", length = s.length;
+  return length < width ? new Array(width - length + 1).join(0) + s : s;
+}
+function formatYear(year) {
+  return year < 0 ? "-" + pad(-year, 6) : year > 9999 ? "+" + pad(year, 6) : pad(year, 4);
+}
+function formatDate(date) {
+  var hours = date.getUTCHours(), minutes = date.getUTCMinutes(), seconds = date.getUTCSeconds(), milliseconds = date.getUTCMilliseconds();
+  return isNaN(date) ? "Invalid Date" : formatYear(date.getUTCFullYear(), 4) + "-" + pad(date.getUTCMonth() + 1, 2) + "-" + pad(date.getUTCDate(), 2) + (milliseconds ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + ":" + pad(seconds, 2) + "." + pad(milliseconds, 3) + "Z" : seconds ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + ":" + pad(seconds, 2) + "Z" : minutes || hours ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + "Z" : "");
+}
+function dsv_default(delimiter) {
+  var reFormat = new RegExp('["' + delimiter + `
+\r]`), DELIMITER = delimiter.charCodeAt(0);
+  function parse(text, f) {
+    var convert, columns, rows = parseRows(text, function(row, i) {
+      if (convert)
+        return convert(row, i - 1);
+      columns = row, convert = f ? customConverter(row, f) : objectConverter(row);
+    });
+    rows.columns = columns || [];
+    return rows;
+  }
+  function parseRows(text, f) {
+    var rows = [], N = text.length, I = 0, n = 0, t, eof = N <= 0, eol = false;
+    if (text.charCodeAt(N - 1) === NEWLINE)
+      --N;
+    if (text.charCodeAt(N - 1) === RETURN)
+      --N;
+    function token() {
+      if (eof)
+        return EOF;
+      if (eol)
+        return eol = false, EOL;
+      var i, j = I, c;
+      if (text.charCodeAt(j) === QUOTE) {
+        while (I++ < N && text.charCodeAt(I) !== QUOTE || text.charCodeAt(++I) === QUOTE)
+          ;
+        if ((i = I) >= N)
+          eof = true;
+        else if ((c = text.charCodeAt(I++)) === NEWLINE)
+          eol = true;
+        else if (c === RETURN) {
+          eol = true;
+          if (text.charCodeAt(I) === NEWLINE)
+            ++I;
+        }
+        return text.slice(j + 1, i - 1).replace(/""/g, '"');
+      }
+      while (I < N) {
+        if ((c = text.charCodeAt(i = I++)) === NEWLINE)
+          eol = true;
+        else if (c === RETURN) {
+          eol = true;
+          if (text.charCodeAt(I) === NEWLINE)
+            ++I;
+        } else if (c !== DELIMITER)
+          continue;
+        return text.slice(j, i);
+      }
+      return eof = true, text.slice(j, N);
+    }
+    while ((t = token()) !== EOF) {
+      var row = [];
+      while (t !== EOL && t !== EOF)
+        row.push(t), t = token();
+      if (f && (row = f(row, n++)) == null)
+        continue;
+      rows.push(row);
+    }
+    return rows;
+  }
+  function preformatBody(rows, columns) {
+    return rows.map(function(row) {
+      return columns.map(function(column) {
+        return formatValue(row[column]);
+      }).join(delimiter);
+    });
+  }
+  function format(rows, columns) {
+    if (columns == null)
+      columns = inferColumns(rows);
+    return [columns.map(formatValue).join(delimiter)].concat(preformatBody(rows, columns)).join(`
+`);
+  }
+  function formatBody(rows, columns) {
+    if (columns == null)
+      columns = inferColumns(rows);
+    return preformatBody(rows, columns).join(`
+`);
+  }
+  function formatRows(rows) {
+    return rows.map(formatRow).join(`
+`);
+  }
+  function formatRow(row) {
+    return row.map(formatValue).join(delimiter);
+  }
+  function formatValue(value) {
+    return value == null ? "" : value instanceof Date ? formatDate(value) : reFormat.test(value += "") ? '"' + value.replace(/"/g, '""') + '"' : value;
+  }
+  return {
+    parse,
+    parseRows,
+    format,
+    formatBody,
+    formatRows,
+    formatRow,
+    formatValue
+  };
+}
+
+// node_modules/d3-dsv/src/csv.js
+var csv = dsv_default(",");
+var csvParse = csv.parse;
+var csvParseRows = csv.parseRows;
+var csvFormat = csv.format;
+var csvFormatBody = csv.formatBody;
+var csvFormatRows = csv.formatRows;
+var csvFormatRow = csv.formatRow;
+var csvFormatValue = csv.formatValue;
+// node_modules/d3-dsv/src/tsv.js
+var tsv = dsv_default("\t");
+var tsvParse = tsv.parse;
+var tsvParseRows = tsv.parseRows;
+var tsvFormat = tsv.format;
+var tsvFormatBody = tsv.formatBody;
+var tsvFormatRows = tsv.formatRows;
+var tsvFormatRow = tsv.formatRow;
+var tsvFormatValue = tsv.formatValue;
+// node_modules/d3-zoom/src/transform.js
+function Transform(k, x, y) {
+  this.k = k;
+  this.x = x;
+  this.y = y;
+}
+Transform.prototype = {
+  constructor: Transform,
+  scale: function(k) {
+    return k === 1 ? this : new Transform(this.k * k, this.x, this.y);
+  },
+  translate: function(x, y) {
+    return x === 0 & y === 0 ? this : new Transform(this.k, this.x + this.k * x, this.y + this.k * y);
+  },
+  apply: function(point) {
+    return [point[0] * this.k + this.x, point[1] * this.k + this.y];
+  },
+  applyX: function(x) {
+    return x * this.k + this.x;
+  },
+  applyY: function(y) {
+    return y * this.k + this.y;
+  },
+  invert: function(location) {
+    return [(location[0] - this.x) / this.k, (location[1] - this.y) / this.k];
+  },
+  invertX: function(x) {
+    return (x - this.x) / this.k;
+  },
+  invertY: function(y) {
+    return (y - this.y) / this.k;
+  },
+  rescaleX: function(x) {
+    return x.copy().domain(x.range().map(this.invertX, this).map(x.invert, x));
+  },
+  rescaleY: function(y) {
+    return y.copy().domain(y.range().map(this.invertY, this).map(y.invert, y));
+  },
+  toString: function() {
+    return "translate(" + this.x + "," + this.y + ") scale(" + this.k + ")";
+  }
+};
+var identity2 = new Transform(1, 0, 0);
+transform.prototype = Transform.prototype;
+function transform(node) {
+  while (!node.__zoom)
+    if (!(node = node.parentNode))
+      return identity2;
+  return node.__zoom;
+}
+// node_modules/polyfill-text-decoder-stream/dist/index.js
+class PolyfillTextDecoderStream extends TransformStream {
+  encoding;
+  fatal;
+  ignoreBOM;
+  constructor(encoding = "utf-8", {
+    fatal = false,
+    ignoreBOM = false
+  } = {}) {
+    const decoder = new TextDecoder(encoding, { fatal, ignoreBOM });
+    super({
+      transform(chunk, controller) {
+        if (typeof chunk === "string") {
+          controller.enqueue(chunk);
+          return;
+        }
+        const decoded = decoder.decode(chunk);
+        if (decoded.length > 0) {
+          controller.enqueue(decoded);
+        }
+      },
+      flush(controller) {
+        const output = decoder.decode();
+        if (output.length > 0) {
+          controller.enqueue(output);
+        }
+      }
+    });
+    this.encoding = encoding;
+    this.fatal = fatal;
+    this.ignoreBOM = ignoreBOM;
+  }
+}
+
+// node_modules/sflow/dist/index.js
+var asyncMaps = (fn, options = {}) => {
+  let i = 0;
+  let tasks = new Map;
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      const id2 = i++;
+      tasks.set(id2, async function() {
+        return fn(chunk, id2);
+      }().then((data) => ({ id: id2, data })));
+      if (tasks.size >= (options.concurrency ?? Infinity)) {
+        const { id: id22, data } = await Promise.race(tasks.values());
+        tasks.delete(id22);
+        ctrl.enqueue(data);
+      }
+    },
+    flush: async (ctrl) => {
+      while (tasks.size) {
+        const { id: id2, data } = await Promise.race(tasks.values());
+        tasks.delete(id2);
+        ctrl.enqueue(data);
+      }
+    }
+  });
+};
+var never = () => new Promise(() => null);
+function cacheLists(store, _options) {
+  const { key = new Error().stack ?? phpdie_default("missing cache key") } = typeof _options === "string" ? { key: _options } : _options ?? {};
+  const chunks = [];
+  const cacheHitPromise = store.has?.(key) || store.get(key);
+  let hitflag = false;
+  return new TransformStream({
+    start: async (ctrl) => {
+      if (!await cacheHitPromise)
+        return;
+      const cached = await store.get(key);
+      if (!cached)
+        return;
+      cached.map((c) => ctrl.enqueue(c));
+      hitflag = true;
+    },
+    transform: async (chunk, ctrl) => {
+      if (await cacheHitPromise || hitflag) {
+        ctrl.terminate();
+        return never();
+      }
+      chunks.push(chunk);
+      ctrl.enqueue(chunk);
+    },
+    flush: async () => await store.set(key, chunks)
+  });
+}
+function cacheSkips(store, _options) {
+  const {
+    key = new Error().stack ?? phpdie_default("missing cache key"),
+    windowSize = 1
+  } = typeof _options === "string" ? { key: _options } : _options ?? {};
+  const chunks = [];
+  const cachePromise = store.get(key);
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      const cache = await cachePromise;
+      const chunked = JSON.stringify(chunk);
+      const inf404 = (idx) => idx == null || idx < 0 ? Infinity : idx;
+      const hitCache = (item) => JSON.stringify(item) === chunked;
+      const cachedContents = cache?.slice(inf404(cache.findIndex(hitCache)));
+      if (cachedContents?.length) {
+        await store.set(key, [...chunks, ...cachedContents].slice(0, windowSize));
+        ctrl.terminate();
+        return await never();
+      }
+      chunks.push(chunk);
+      ctrl.enqueue(chunk);
+    },
+    flush: async () => {
+      await store.set(key, chunks.slice(0, windowSize));
+    }
+  });
+}
+function cacheTails(store, _options) {
+  const { key = new Error().stack ?? phpdie_default("missing cache key") } = typeof _options === "string" ? { key: _options } : _options ?? {};
+  const chunks = [];
+  const cachePromise = Promise.withResolvers();
+  const t = new TransformStream;
+  const w = t.writable.getWriter();
+  const writable = new WritableStream({
+    start: async () => cachePromise.resolve(await store.get(key)),
+    write: async (chunk, ctrl) => {
+      const cache = await cachePromise.promise;
+      if (cache && $equals(chunk, cache[0])) {
+        await store.set(key, [...chunks, ...cache]);
+        for await (const item of cache)
+          await w.write(item);
+        await w.close();
+        ctrl.error(new Error("cached"));
+        return await never();
+      }
+      chunks.push(chunk);
+      await w.write(chunk);
+    },
+    close: async () => {
+      await store.set(key, [...chunks]);
+      await w.close();
+    },
+    abort: () => w.abort()
+  });
+  return { writable, readable: t.readable };
+}
+function chunkBys(compareFn) {
+  let chunks = [];
+  let lastOrder;
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      const order = await compareFn(chunk);
+      if (lastOrder && lastOrder !== order)
+        ctrl.enqueue(chunks.splice(0, Infinity));
+      chunks.push(chunk);
+      lastOrder = order;
+    },
+    flush: async (ctrl) => void (chunks.length && ctrl.enqueue(chunks))
+  });
+}
+function chunkIfs(predicate, { inclusive = false } = {}) {
+  let chunks = [];
+  let i = 0;
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      const cond = await predicate(chunk, i++, chunks);
+      if (!inclusive && !cond)
+        chunks.length && ctrl.enqueue(chunks.splice(0, Infinity));
+      chunks.push(chunk);
+      if (!cond)
+        ctrl.enqueue(chunks.splice(0, Infinity));
+    },
+    flush: async (ctrl) => void (chunks.length && ctrl.enqueue(chunks))
+  });
+}
+function chunkIntervals(interval2 = 0) {
+  let chunks = [];
+  let id2 = null;
+  return new TransformStream({
+    start: (ctrl) => {
+      id2 = setInterval(() => ctrl.enqueue(chunks.splice(0, Infinity)), interval2);
+    },
+    transform: async (chunk) => {
+      chunks.push(chunk);
+    },
+    flush: async (ctrl) => {
+      if (chunks.length)
+        ctrl.enqueue(chunks.splice(0, Infinity));
+      id2 !== null && clearInterval(id2);
+    }
+  });
+}
+function chunks(n = Infinity) {
+  let chunks2 = [];
+  if (n <= 0)
+    throw new Error("Buffer size must be greater than 0");
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      chunks2.push(chunk);
+      if (chunks2.length >= n)
+        ctrl.enqueue(chunks2.splice(0, Infinity));
+    },
+    flush: async (ctrl) => void (chunks2.length && ctrl.enqueue(chunks2))
+  });
+}
+var toStream = (src) => src instanceof ReadableStream ? src : from(src ?? []);
+function maps(fn) {
+  let i = 0;
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      const ret = fn(chunk, i++);
+      const val = ret instanceof Promise ? await ret : ret;
+      ctrl.enqueue(val);
+    }
+  });
+}
+function nils() {
+  return new WritableStream;
+}
+var concats = (srcs) => {
+  if (!srcs)
+    return new TransformStream;
+  const upstream = new TransformStream;
+  return {
+    writable: upstream.writable,
+    readable: concatStream([upstream.readable, concatStream(srcs)])
+  };
+};
+var concatStream = (srcs) => {
+  if (!srcs)
+    return new ReadableStream({ start: (c) => c.close() });
+  const t = new TransformStream;
+  const w = t.writable.getWriter();
+  toStream(srcs).pipeThrough(maps(toStream)).pipeThrough(maps(async (s) => {
+    const r = s.getReader();
+    while (true) {
+      const { value, done } = await r.read();
+      if (done)
+        break;
+      await w.write(value);
+    }
+  })).pipeTo(nils()).then(() => w.close()).catch((reason) => w.abort(reason));
+  return t.readable;
+};
+var confluences = ({
+  order = "breadth"
+} = {}) => {
+  const baseError = new Error;
+  if (order !== "breadth")
+    phpdie_default("not implemented");
+  const { writable, readable: sources } = new TransformStream;
+  const srcsQueue = [];
+  const readable = new ReadableStream({
+    async pull(ctrl) {
+      while (true) {
+        const src = await async function() {
+          const r2 = sources.getReader();
+          const { done: done2, value: src2 } = await r2.read();
+          r2.releaseLock();
+          if (done2)
+            return srcsQueue.shift();
+          return src2;
+        }();
+        if (!src)
+          return ctrl.close();
+        const r = src.getReader();
+        const { done, value } = await r.read();
+        r.releaseLock();
+        if (done)
+          continue;
+        srcsQueue.push(src);
+        ctrl.enqueue(value);
+        return;
+      }
+    }
+  });
+  return { writable, readable };
+};
+function convolves(n) {
+  const buffer2 = [];
+  return new TransformStream({
+    transform(chunk, controller) {
+      buffer2.push(chunk);
+      if (buffer2.length > n)
+        buffer2.shift();
+      if (buffer2.length === n)
+        controller.enqueue([...buffer2]);
+    },
+    flush(controller) {
+      while (buffer2.length > 1) {
+        buffer2.shift();
+        if (buffer2.length === n)
+          controller.enqueue([...buffer2]);
+      }
+    }
+  });
+}
+function debounces(t) {
+  let id2 = null;
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      if (id2)
+        clearTimeout(id2);
+      id2 = setTimeout(() => {
+        ctrl.enqueue(chunk);
+        id2 = null;
+      }, t);
+    },
+    flush: async () => {
+      while (id2)
+        await new Promise((r) => setTimeout(r, t / 2));
+    }
+  });
+}
+var filters = (fn) => {
+  let i = 0;
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      if (fn) {
+        const shouldEnqueue = await fn(chunk, i++);
+        if (shouldEnqueue)
+          ctrl.enqueue(chunk);
+      } else {
+        const isNull = chunk === undefined || chunk === null;
+        if (!isNull)
+          ctrl.enqueue(chunk);
+      }
+    }
+  });
+};
+function flatMaps(fn) {
+  let i = 0;
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      const ret = fn(chunk, i++);
+      const val = ret instanceof Promise ? await ret : ret;
+      val.map((e) => ctrl.enqueue(e));
+    }
+  });
+}
+function flats() {
+  const emptyError = new Error("Flatten for empty array [] in stream is not supported yet, To fix this error, you can add a .filter(array=>array.length) stage before flat");
+  return new TransformStream({
+    transform: async (a, ctrl) => {
+      a.length || phpdie_default(emptyError);
+      a.map((e) => ctrl.enqueue(e));
+    }
+  });
+}
+function forEachs(fn) {
+  let i = 0;
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      const ret = fn(chunk, i++);
+      ret instanceof Promise && await ret;
+      ctrl.enqueue(chunk);
+    }
+  });
+}
+function heads(n = 1) {
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      return n-- > 0 ? ctrl.enqueue(chunk) : await never();
+    }
+  });
+}
+function limits(n, { terminate = true } = {}) {
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      ctrl.enqueue(chunk);
+      if (--n === 0) {
+        terminate && ctrl.terminate();
+        return never();
+      }
+    },
+    flush: () => {}
+  }, { highWaterMark: 1 }, { highWaterMark: 0 });
+}
+var throughs = (arg) => {
+  if (!arg)
+    return new TransformStream;
+  if (typeof arg !== "function")
+    return throughs((s) => s.pipeThrough(arg));
+  const fn = arg;
+  const { writable, readable } = new TransformStream;
+  return { writable, readable: fn(readable) };
+};
+var lines = ({ EOL: EOL2 = "KEEP" } = {}) => {
+  const CRLFMap = {
+    KEEP: "$1",
+    LF: `
+`,
+    CRLF: `\r
+`,
+    NONE: ""
+  };
+  return throughs((r) => r.pipeThrough(flatMaps((s) => s.split(/(?<=\n)/g))).pipeThrough(chunkIfs((ch) => ch.indexOf(`
+`) === -1, { inclusive: true })).pipeThrough(maps((chunks2) => chunks2.join("").replace(/(\r?\n?)$/, CRLFMap[EOL2]))));
+};
+function unpromises(promise) {
+  const tr = new TransformStream;
+  (async function() {
+    const s = await promise;
+    await s.pipeTo(tr.writable);
+  })().catch((error) => {
+    tr.readable.cancel(error).catch(() => {
+      throw error;
+    });
+  }).then();
+  return tr.readable;
+}
+function bys(arg) {
+  if (!arg)
+    return new TransformStream;
+  if (typeof arg !== "function")
+    return bys((s) => s.pipeThrough(arg));
+  const fn = arg;
+  const { writable, readable } = new TransformStream;
+  return { writable, readable: unpromises(fn(readable)) };
+}
+function peeks(fn) {
+  let i = 0;
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      ctrl.enqueue(chunk);
+      const ret = fn(chunk, i++);
+      const val = ret instanceof Promise ? await ret : ret;
+    }
+  });
+}
+function logs(mapFn = (s, i) => s) {
+  return bys(peeks(async (e, i) => {
+    const ret = mapFn(e, i);
+    const val = ret instanceof Promise ? await ret : ret;
+    console.log(typeof val === "string" ? val.replace(/\n$/, "") : val);
+  }));
+}
+function mapAddFields(key, fn) {
+  let i = 0;
+  return new TransformStream({
+    transform: async (chunk, ctrl) => ctrl.enqueue({ ...chunk, [key]: await fn(chunk, i++) })
+  });
+}
+var wseMerges = merge;
+var parallels = (...srcs) => wseMerges()(from(srcs));
+var merges = (...srcs) => {
+  if (!srcs.length)
+    return new TransformStream;
+  const upstream = new TransformStream;
+  return {
+    writable: upstream.writable,
+    readable: parallels(upstream.readable, ...srcs.map(toStream))
+  };
+};
+async function* streamAsyncIterator() {
+  const reader = this.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        return;
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+var mergeStream = (...srcs) => {
+  if (!srcs.length)
+    return new ReadableStream({ start: (c) => c.close() });
+  if (srcs.length === 1)
+    return toStream(srcs[0]);
+  const t = new TransformStream;
+  const w = t.writable.getWriter();
+  const streams = srcs.map(toStream);
+  Promise.all(streams.map(async (s) => {
+    for await (const chunk of Object.assign(s, {
+      [Symbol.asyncIterator]: streamAsyncIterator
+    }))
+      await w.write(chunk);
+  })).then(async () => w.close()).catch((error) => {
+    console.error(error);
+    return Promise.all([
+      t.writable.abort(error),
+      ...streams.map((e) => e.cancel(error))
+    ]);
+  });
+  return t.readable;
+};
+var emptyStream = () => new ReadableStream({ start: (c) => c.close() });
+function mergeStreamsBy(transform2, sources) {
+  if (!sources)
+    return (srcs) => mergeStreamsBy(transform2, srcs);
+  if (!sources.length)
+    return emptyStream();
+  const streams = sources.map((s) => toStream(s));
+  const readers = streams.map((stream) => stream.getReader());
+  let slots = streams.map(() => null);
+  return new ReadableStream({
+    pull: async (ctrl) => {
+      const results = await Promise.all(readers.map(async (reader, i) => slots[i] ??= await reader.read()));
+      slots = await transform2([...slots], ctrl);
+      if (slots.length !== streams.length)
+        phpdie_default("slot length mismatch");
+    }
+  });
+}
+function mergeStreamsByAscend(ordFn, sources) {
+  if (!sources)
+    return (sources2) => mergeStreamsByAscend(ordFn, sources2);
+  let lastEmit = null;
+  return mergeStreamsBy(async (slots, ctrl) => {
+    const cands = slots.filter((e) => e?.done === false).map((e) => e.value);
+    if (!cands.length) {
+      ctrl.close();
+      return [];
+    }
+    const peak = $sortBy(ordFn, cands)[0];
+    const index = slots.findIndex((e) => e?.done === false && e?.value === peak);
+    if (lastEmit && lastEmit.value !== $sortBy(ordFn, [lastEmit.value, peak])[0] && ordFn(lastEmit.value) !== ordFn(peak))
+      phpdie_default(new Error("MergeStreamError: one of sources is not ordered by ascending", {
+        cause: {
+          prevOrd: ordFn(lastEmit.value),
+          currOrd: ordFn(peak),
+          prev: lastEmit.value,
+          curr: peak
+        }
+      }));
+    lastEmit = { value: peak };
+    ctrl.enqueue(peak);
+    return slots.toSpliced(index, 1, null);
+  }, sources);
+}
+function mergeStreamsByDescend(ordFn, sources) {
+  if (!sources)
+    return (srcs) => mergeStreamsByDescend(ordFn, srcs);
+  let lastEmit = null;
+  return mergeStreamsBy(async (slots, ctrl) => {
+    const cands = slots.filter((e) => e?.done === false).map((e) => e.value);
+    if (!cands.length) {
+      ctrl.close();
+      return [];
+    }
+    const peak = $sortBy(ordFn, cands).toReversed()[0];
+    const index = slots.findIndex((e) => e?.done === false && e?.value === peak);
+    if (lastEmit && lastEmit.value !== $sortBy(ordFn, [lastEmit.value, peak]).toReversed()[0] && ordFn(lastEmit.value) !== ordFn(peak))
+      phpdie_default(new Error("MergeStreamError: one of sources is not ordered by descending", {
+        cause: {
+          prevOrd: ordFn(lastEmit.value),
+          currOrd: ordFn(peak),
+          prev: lastEmit.value,
+          curr: peak
+        }
+      }));
+    lastEmit = { value: peak };
+    ctrl.enqueue(peak);
+    return slots.toSpliced(index, 1, null);
+  }, sources);
+}
+var pMaps = (fn, options = {}) => {
+  let i = 0;
+  let promises = [];
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      promises.push(fn(chunk, i++));
+      if (promises.length >= (options.concurrency ?? Infinity))
+        ctrl.enqueue(await promises.shift());
+    },
+    flush: async (ctrl) => {
+      while (promises.length)
+        ctrl.enqueue(await promises.shift());
+    }
+  });
+};
+var portals = (arg) => {
+  if (!arg)
+    return new TransformStream;
+  if (typeof arg !== "function")
+    return throughs((s) => s.pipeThrough(arg));
+  const fn = arg;
+  const { writable, readable } = new TransformStream;
+  return { writable, readable: fn(readable) };
+};
+var reduceEmits = (fn, _state) => {
+  let i = 0;
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      const { next, emit } = await fn(_state, chunk, i++);
+      _state = next;
+      ctrl.enqueue(emit);
+    }
+  });
+};
+var reduces = (fn, state) => {
+  let i = 0;
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      const ret = fn(state, chunk, i++);
+      const val = ret instanceof Promise ? await ret : ret;
+      state = await val;
+      ctrl.enqueue(state);
+    }
+  });
+};
+function riffles(sep) {
+  let last2;
+  return new TransformStream({
+    transform: (chunk, ctrl) => {
+      if (last2 !== undefined) {
+        ctrl.enqueue(last2);
+        ctrl.enqueue(sep);
+      }
+      last2 = chunk;
+    },
+    flush: (ctrl) => ctrl.enqueue(last2)
+  });
+}
+function skips(n = 1) {
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      if (n <= 0)
+        ctrl.enqueue(chunk);
+      else
+        n--;
+    }
+  });
+}
+function slices(start2 = 0, end = Infinity) {
+  const count = end - start2;
+  const { readable, writable } = new TransformStream;
+  return {
+    writable,
+    readable: readable.pipeThrough(skips(start2)).pipeThrough(limits(count))
+  };
+}
+var matchs = (matcher) => {
+  return new TransformStream({
+    transform: (chunk, ctrl) => ctrl.enqueue(chunk.match(matcher))
+  });
+};
+var matchAlls = (matcher) => {
+  return new TransformStream({
+    transform: (chunk, ctrl) => ctrl.enqueue(chunk.matchAll(matcher))
+  });
+};
+var replaces = (searchValue, replacement) => {
+  return maps((s) => typeof replacement === "string" ? s.replace(searchValue, replacement) : replaceAsync(s, searchValue, replacement));
+};
+var replaceAlls = (searchValue, replacement) => {
+  return maps((s) => typeof replacement === "string" ? s.replaceAll(searchValue, replacement) : replaceAsync(s, searchValue, replacement));
+};
+function tails(n = 1) {
+  let chunks2 = [];
+  return new TransformStream({
+    transform: (chunk) => {
+      chunks2.push(chunk);
+      if (chunks2.length > n)
+        chunks2.shift();
+    },
+    flush: (ctrl) => {
+      chunks2.map((e) => ctrl.enqueue(e));
+    }
+  });
+}
+var tees = (arg) => {
+  if (!arg)
+    return new TransformStream;
+  if (arg instanceof WritableStream)
+    return tees((s) => s.pipeTo(arg));
+  const fn = arg;
+  const { writable, readable } = new TransformStream;
+  const [a, b] = readable.tee();
+  fn(a);
+  return { writable, readable: b };
+};
+function terminates(signal) {
+  return throughs((r) => r.pipeThrough(new TransformStream, { signal }));
+}
+function throttles(interval2, { drop = false, keepLast = true } = {}) {
+  let timerId = null;
+  let cdPromise = Promise.withResolvers();
+  let lasts = [];
+  return new TransformStream({
+    transform: async (chunk, ctrl) => {
+      if (timerId) {
+        if (keepLast)
+          lasts = [chunk];
+        if (drop)
+          return;
+        await cdPromise.promise;
+      }
+      lasts = [];
+      ctrl.enqueue(chunk);
+      [cdPromise, timerId] = [
+        Promise.withResolvers(),
+        setTimeout(() => {
+          timerId = null;
+          cdPromise.resolve();
+        }, interval2)
+      ];
+    },
+    flush: async (ctrl) => {
+      while (timerId)
+        await new Promise((r) => setTimeout(r, interval2 / 2));
+      lasts.map((e) => ctrl.enqueue(e));
+    }
+  });
+}
+var uniqs = () => {
+  const set4 = new Set;
+  return throughs((s) => s.pipeThrough(filters((x) => {
+    if (set4.has(x))
+      return false;
+    set4.add(x);
+    return true;
+  })));
+};
+var uniqBys = (keyFn) => {
+  const set4 = new Set;
+  return throughs((s) => s.pipeThrough(filters(async (x) => {
+    const key = await keyFn(x);
+    if (set4.has(key))
+      return false;
+    set4.add(key);
+    return true;
+  })));
+};
+function unwinds(key) {
+  return flatMaps((e) => import_unwind_array.unwind(e, { path: key }));
+}
+function csvFormats(header) {
+  const _header = typeof header === "string" ? header.split(",") : header;
+  return new TransformStream({
+    start: (ctrl) => ctrl.enqueue(_header.join(",") + `
+`),
+    transform: (chunk, ctrl) => ctrl.enqueue(csvFormatBody([chunk], _header) + `
+`)
+  });
+}
+function csvParses(header) {
+  const _header = typeof header === "string" ? header.split(",") : header;
+  let i = 0;
+  return throughs((r) => r.pipeThrough(lines({ EOL: "LF" })).pipeThrough(skips(1)).pipeThrough(maps((line) => csvParse(_header + `
+` + line)[0])));
+}
+function tsvFormats(header) {
+  const sep = "\t";
+  const _header = typeof header === "string" ? header.split(sep) : header;
+  return new TransformStream({
+    start: (ctrl) => ctrl.enqueue(_header.join(sep) + `
+`),
+    transform: (chunk, ctrl) => ctrl.enqueue(tsvFormatBody([chunk], _header) + `
+`)
+  });
+}
+function tsvParses(header) {
+  const _header = typeof header === "string" ? header.split("\t") : header;
+  let i = 0;
+  return throughs((r) => r.pipeThrough(lines({ EOL: "LF" })).pipeThrough(skips(1)).pipeThrough(maps((line) => tsvParse(_header + `
+` + line)[0])));
+}
+function sflow(...srcs) {
+  let r = srcs.length === 1 ? toStream(srcs[0]) : concatStream(srcs);
+  return Object.assign(r, {
+    _type: null,
+    get readable() {
+      return r;
+    },
+    portal: (...args) => sflow(r.pipeThrough(portals(...args))),
+    through: (...args) => sflow(r.pipeThrough(_throughs(...args))),
+    by: (...args) => sflow(r.pipeThrough(_throughs(...args))),
+    byLazy: (t) => _byLazy(r, t),
+    mapAddField: (...args) => sflow(r.pipeThrough(mapAddFields(...args))),
+    cacheSkip: (...args) => sflow(r).byLazy(cacheSkips(...args)),
+    cacheList: (...args) => sflow(r).byLazy(cacheLists(...args)),
+    cacheTail: (...args) => sflow(r).byLazy(cacheTails(...args)),
+    chunkBy: (...args) => sflow(r.pipeThrough(chunkBys(...args))),
+    chunkIf: (...args) => sflow(r.pipeThrough(chunkIfs(...args))),
+    buffer: (...args) => sflow(r.pipeThrough(chunks(...args))),
+    chunk: (...args) => sflow(r.pipeThrough(chunks(...args))),
+    convolve: (...args) => sflow(r.pipeThrough(convolves(...args))),
+    abort: (...args) => sflow(r.pipeThrough(terminates(...args))),
+    chunkInterval: (...args) => sflow(r.pipeThrough(chunkIntervals(...args))),
+    interval: (...args) => sflow(r.pipeThrough(chunkIntervals(...args))),
+    debounce: (...args) => sflow(r.pipeThrough(debounces(...args))),
+    filter: (...args) => sflow(r.pipeThrough(filters(...args))),
+    flatMap: (...args) => sflow(r.pipeThrough(flatMaps(...args))),
+    flat: (...args) => sflow(r).byLazy(flats(...args)),
+    join: (...args) => sflow(r.pipeThrough(riffles(...args))),
+    match: (...args) => sflow(r.pipeThrough(matchs(...args))),
+    matchAll: (...args) => sflow(r.pipeThrough(matchAlls(...args))),
+    replace: (...args) => sflow(r.pipeThrough(replaces(...args))),
+    replaceAll: (...args) => sflow(r.pipeThrough(replaceAlls(...args))),
+    merge: (...args) => sflow(r.pipeThrough(merges(...args))),
+    concat: (srcs2) => sflow(r.pipeThrough(concats(srcs2))),
+    confluence: (...args) => sflow(r.pipeThrough(confluences(...args))),
+    confluenceByZip: () => sflow(r).by(confluences()),
+    confluenceByConcat: () => sflow(r).by((srcs2) => concatStream(srcs2)),
+    confluenceByParallel: () => sflow(r).by((srcs2) => sflow(srcs2).toArray().then((srcs3) => mergeStream(...srcs3))).confluence(),
+    confluenceByAscend: (ordFn) => sflow(r).chunk().map((srcs2) => mergeStreamsByAscend(ordFn, srcs2)).confluence(),
+    confluenceByDescend: (ordFn) => sflow(r).chunk().map((srcs2) => mergeStreamsByDescend(ordFn, srcs2)).confluence(),
+    limit: (...args) => sflow(r).byLazy(limits(...args)),
+    head: (...args) => sflow(r.pipeThrough(heads(...args))),
+    map: (...args) => sflow(r.pipeThrough(maps(...args))),
+    log: (...args) => sflow(r.pipeThrough(logs(...args))),
+    uniq: (...args) => sflow(r.pipeThrough(uniqs(...args))),
+    uniqBy: (...args) => sflow(r.pipeThrough(uniqBys(...args))),
+    unwind: (...args) => sflow(r.pipeThrough(unwinds(...args))),
+    asyncMap: (...args) => sflow(r.pipeThrough(asyncMaps(...args))),
+    pMap: (...args) => sflow(r.pipeThrough(pMaps(...args))),
+    peek: (...args) => sflow(r.pipeThrough(peeks(...args))),
+    riffle: (...args) => sflow(r.pipeThrough(riffles(...args))),
+    forEach: (...args) => sflow(r.pipeThrough(forEachs(...args))),
+    reduce: (...args) => sflow(r.pipeThrough(reduces(...args))),
+    reduceEmit: (...args) => sflow(r.pipeThrough(reduceEmits(...args))),
+    skip: (...args) => sflow(r.pipeThrough(skips(...args))),
+    slice: (...args) => sflow(r.pipeThrough(slices(...args))),
+    tail: (...args) => sflow(r.pipeThrough(tails(...args))),
+    tees: (...args) => sflow(r.pipeThrough(_tees(...args))),
+    forkTo: (...args) => sflow(r.pipeThrough(_tees(...args))),
+    fork: () => {
+      let b;
+      [r, b] = r.tee();
+      return sflow(b);
+    },
+    throttle: (...args) => sflow(r.pipeThrough(throttles(...args))),
+    csvFormat: (...args) => sflow(r.pipeThrough(csvFormats(...args))),
+    tsvFormat: (...args) => sflow(r.pipeThrough(tsvFormats(...args))),
+    csvParse: (...args) => sflow(r.pipeThrough(csvParses(...args))),
+    tsvParse: (...args) => sflow(r.pipeThrough(tsvParses(...args))),
+    preventAbort: () => sflow(r.pipeThrough(throughs(), { preventAbort: true })),
+    preventClose: () => sflow(r.pipeThrough(throughs(), { preventClose: true })),
+    preventCancel: () => sflow(r.pipeThrough(throughs(), { preventCancel: true })),
+    onStart: (start2) => sflow(r).by(new TransformStream({ start: start2 })),
+    onTransform: (transform2) => sflow(r).by(new TransformStream({ transform: transform2 })),
+    onFlush: (flush) => sflow(r).by(new TransformStream({ flush })),
+    done: () => r.pipeTo(nils()),
+    end: (dst = nils()) => r.pipeTo(dst),
+    to: (dst = nils()) => r.pipeTo(dst),
+    run: () => r.pipeTo(nils()),
+    toEnd: () => r.pipeTo(nils()),
+    toNil: () => r.pipeTo(nils()),
+    toArray: () => toArray(r),
+    toCount: async () => {
+      let i = 0;
+      const d = r.getReader();
+      while (!(await d.read()).done)
+        i++;
+      return i;
+    },
+    toFirst: () => toPromise(sflow(r).limit(1, { terminate: true })),
+    toLast: () => toPromise(sflow(r).tail(1)),
+    toExactlyOne: async () => {
+      const a = await toArray(r);
+      a.length !== 1 || phpdie_default(`Expect exactly 1 Item, but got ${a.length}`);
+      return a[0];
+    },
+    toOne: async () => {
+      const a = await toArray(r);
+      if (a.length > 1)
+        phpdie_default(`Expect only 1 Item, but got ${a.length}`);
+      return a[0];
+    },
+    toAtLeastOne: async () => {
+      const a = await toArray(r);
+      if (a.length > 1)
+        phpdie_default(`Expect only 1 Item, but got ${a.length}`);
+      if (a.length < 1)
+        phpdie_default(`Expect at least 1 Item, but got ${a.length}`);
+      return a[0];
+    },
+    toLog: (...args) => sflow(r.pipeThrough(logs(...args))).done(),
+    lines: (...args) => sflow(r.pipeThrough(lines(...args))),
+    toResponse: (init2) => new Response(r, init2),
+    text: (init2) => new Response(r.pipeThrough(new PolyfillTextEncoderStream), init2).text(),
+    json: (init2) => new Response(r.pipeThrough(new PolyfillTextEncoderStream), init2).json(),
+    blob: (init2) => new Response(sflow(r), init2).blob(),
+    arrayBuffer: (init2) => new Response(r, init2).arrayBuffer(),
+    [Symbol.asyncIterator]: streamAsyncIterator
+  });
+}
+var _tees = (arg) => {
+  if (!arg)
+    return new TransformStream;
+  if (arg instanceof WritableStream)
+    return tees((s) => s.pipeTo(arg));
+  const fn = arg;
+  const { writable, readable } = new TransformStream;
+  const [a, b] = readable.tee();
+  fn(sflow(a));
+  return { writable, readable: b };
+};
+var _throughs = (arg) => {
+  if (!arg)
+    return new TransformStream;
+  if (typeof arg !== "function")
+    return throughs((s) => s.pipeThrough(arg));
+  const fn = arg;
+  const { writable, readable } = new TransformStream;
+  return { writable, readable: sflow(fn(sflow(readable))) };
+};
+function _byLazy(r, t) {
+  const reader = r.getReader();
+  const tw = t.writable.getWriter();
+  const tr = t.readable.getReader();
+  return sflow(new ReadableStream({
+    start: async (ctrl) => {
+      (async function() {
+        while (true) {
+          const { done, value } = await tr.read();
+          if (done)
+            return ctrl.close();
+          ctrl.enqueue(value);
+        }
+      })();
+    },
+    pull: async (ctrl) => {
+      const { done, value } = await reader.read();
+      if (done)
+        return tw.close();
+      await tw.write(value);
+    },
+    cancel: async (r2) => {
+      reader.cancel(r2);
+      tr.cancel(r2);
+    }
+  }, { highWaterMark: 0 }));
+}
+var src_default = sflow;
+
+// node_modules/from-node-stream/dist/index.js
+function fromReadable(i) {
+  return new ReadableStream({
+    start: (c) => {
+      i.on("data", (data) => c.enqueue(data));
+      i.on("close", () => c.close());
+      i.on("error", (err) => c.error(err));
+    },
+    cancel: (reason) => (i.destroy?.(reason), undefined)
+  });
+}
+function fromWritable(i) {
+  return new WritableStream({
+    start: (c) => (i.on("error", (err) => c.error(err)), undefined),
+    abort: (reason) => (i.destroy?.(reason), undefined),
+    write: (data, c) => (i.write(data), undefined),
+    close: () => (i.end(), undefined)
+  });
+}
+
+// index.ts
+import * as pty from "node-pty";
+
+// createIdleWatcher.ts
+function createIdleWatcher(onIdle, idleTimeout) {
+  let lastActiveTime = new Date;
+  let idleTimeoutId = null;
+  return {
+    ping: () => {
+      if (idleTimeoutId) {
+        clearTimeout(idleTimeoutId);
+      }
+      idleTimeoutId = setTimeout(() => {
+        clearTimeout(idleTimeoutId);
+        onIdle();
+      }, idleTimeout);
+      lastActiveTime = new Date;
+    },
+    getLastActiveTime: () => lastActiveTime
+  };
+}
+
+// removeControlCharacters.ts
+function removeControlCharacters(str) {
+  return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
+}
+
+// utils.ts
+function sleepms(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// index.ts
+if (__require.main == __require.module)
+  await main();
+async function main() {}
+async function claudeYes({ continueOnCrash, exitOnIdle, claudeArgs = [] } = {}) {
+  const defaultTimeout = 5000;
+  const idleTimeout = typeof exitOnIdle === "number" ? exitOnIdle : defaultTimeout;
+  console.log("⭐ Starting claude, automatically responding to yes/no prompts...");
+  console.log("⚠️ Important Security Warning: Only run this on trusted repositories. This tool automatically responds to prompts and can execute commands without user confirmation. Be aware of potential prompt injection attacks where malicious code or instructions could be embedded in files or user inputs to manipulate the automated responses.");
+  process.stdin.setRawMode?.(true);
+  const prefix = "";
+  const PREFIXLENGTH = prefix.length;
+  const shellOutputStream = new TransformStream;
+  const outputWriter = shellOutputStream.writable.getWriter();
+  let shell = pty.spawn("claude", claudeArgs, {
+    cols: process.stdout.columns - PREFIXLENGTH,
+    rows: process.stdout.rows,
+    cwd: process.cwd(),
+    env: process.env
+  });
+  async function onData(data) {
+    await outputWriter.write(data);
+  }
+  shell.onData(onData);
+  shell.onExit(function onExit({ exitCode }) {
+    if (continueOnCrash) {
+      if (exitCode !== 0) {
+        console.log("Claude crashed, restarting...");
+        shell = pty.spawn("claude", ["continue", "--continue"], {
+          cols: process.stdout.columns - PREFIXLENGTH,
+          rows: process.stdout.rows,
+          cwd: process.cwd(),
+          env: process.env
+        });
+        shell.onData(onData);
+        shell.onExit(onExit);
+      }
+    }
+    process.exit(exitCode);
+  });
+  const exitClaudeCode = async () => {
+    await src_default(["\r", "/exit", "\r"]).forEach(async (e) => {
+      await sleepms(200);
+      shell.write(e);
+    }).run();
+    let exited = false;
+    await Promise.race([
+      new Promise((resolve) => shell.onExit(() => {
+        resolve();
+        exited = true;
+      })),
+      new Promise((resolve) => setTimeout(() => {
+        if (exited)
+          return;
+        shell.kill();
+        resolve();
+      }, 5000))
+    ]);
+  };
+  process.stdout.on("resize", () => {
+    const { columns, rows } = process.stdout;
+    shell.resize(columns - PREFIXLENGTH, rows);
+  });
+  const shellStdio = {
+    writable: new WritableStream({ write: (data) => shell.write(data), close: () => {} }),
+    readable: shellOutputStream.readable
+  };
+  const idleWatcher = createIdleWatcher(async () => {
+    if (exitOnIdle) {
+      console.log("Claude is idle, exiting...");
+      await exitClaudeCode();
+    }
+  }, idleTimeout);
+  await src_default(fromReadable(process.stdin)).map((buffer2) => buffer2.toString()).by(shellStdio).forkTo((e) => e.map((e2) => removeControlCharacters(e2)).map((e2) => e2.replaceAll("\r", "")).forEach(async (e2) => {
+    if (e2.match(/❯ 1. Yes/)) {
+      await sleepms(200);
+      shell.write("\r");
+    }
+  }).forEach(async (e2) => {
+    if (e2.match(/❯ 1. Dark mode✔|Press Enter to continue…/)) {
+      await sleepms(200);
+      shell.write("\r");
+    }
+  }).run()).replaceAll(/.*(?:\r\n?|\r?\n)/g, (line) => prefix + line).forEach(() => idleWatcher.ping()).map((e) => !process.stdout.isTTY ? removeControlCharacters(e) : e).to(fromWritable(process.stdout));
+}
+export {
+  removeControlCharacters,
+  claudeYes as default
+};